S283 Planetary Science &n…he Search for Life DVD 2/DVD-ROM.iso/install/jre1_3/lib/rt.jar/java/beans/Introspector.class

Java Class File | 1979-12-31 | 12.3 KB | 773 lines

package java.beans;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.security.AccessController;
import java.util.Enumeration;
import java.util.Hashtable;

public class Introspector {
   public static final int USE_ALL_BEANINFO = 1;
   public static final int IGNORE_IMMEDIATE_BEANINFO = 2;
   public static final int IGNORE_ALL_BEANINFO = 3;
   private BeanInfo informant;
   private boolean propertyChangeSource = false;
   private Class beanClass;
   private BeanInfo superBeanInfo;
   private BeanInfo[] additionalBeanInfo;
   private static Hashtable beanInfoCache = new Hashtable();
   private static Class eventListenerType;
   private String defaultEventName;
   private String defaultPropertyName;
   private int defaultEventIndex = -1;
   private int defaultPropertyIndex = -1;
   private Hashtable methods = new Hashtable();
   private static Hashtable declaredMethodCache;
   private Hashtable properties = new Hashtable();
   private Hashtable events = new Hashtable();
   private static String[] searchPath;
   // $FF: synthetic field
   static Class class$java$beans$BeanInfo;
   // $FF: synthetic field
   static Class class$java$beans$PropertyVetoException;
   // $FF: synthetic field
   static Class class$java$util$TooManyListenersException;
   // $FF: synthetic field
   static Class class$java$util$EventObject;
   // $FF: synthetic field
   static Class class$java$util$EventListener;

   public static BeanInfo getBeanInfo(Class var0) throws IntrospectionException {
      GenericBeanInfo var1 = (GenericBeanInfo)beanInfoCache.get(var0);
      if (var1 == null) {
         var1 = (new Introspector(var0, (Class)null, 1)).getBeanInfo();
         beanInfoCache.put(var0, var1);
      }

      return new GenericBeanInfo(var1);
   }

   public static BeanInfo getBeanInfo(Class var0, int var1) throws IntrospectionException {
      GenericBeanInfo var2 = (new Introspector(var0, (Class)null, var1)).getBeanInfo();
      return new GenericBeanInfo(var2);
   }

   public static BeanInfo getBeanInfo(Class var0, Class var1) throws IntrospectionException {
      GenericBeanInfo var2 = (new Introspector(var0, var1, 1)).getBeanInfo();
      return new GenericBeanInfo(var2);
   }

   public static String decapitalize(String var0) {
      if (var0 != null && var0.length() != 0) {
         if (var0.length() > 1 && Character.isUpperCase(var0.charAt(1)) && Character.isUpperCase(var0.charAt(0))) {
            return var0;
         } else {
            char[] var1 = var0.toCharArray();
            var1[0] = Character.toLowerCase(var1[0]);
            return new String(var1);
         }
      } else {
         return var0;
      }
   }

   public static synchronized String[] getBeanInfoSearchPath() {
      String[] var0 = new String[searchPath.length];

      for(int var1 = 0; var1 < searchPath.length; ++var1) {
         var0[var1] = searchPath[var1];
      }

      return var0;
   }

   public static synchronized void setBeanInfoSearchPath(String[] var0) {
      SecurityManager var1 = System.getSecurityManager();
      if (var1 != null) {
         var1.checkPropertiesAccess();
      }

      searchPath = var0;
   }

   public static void flushCaches() {
      beanInfoCache.clear();
      declaredMethodCache.clear();
   }

   public static void flushFromCaches(Class var0) {
      beanInfoCache.remove(var0);
      declaredMethodCache.remove(var0);
   }

   private Introspector(Class var1, Class var2, int var3) throws IntrospectionException {
      this.beanClass = var1;
      if (var2 != null) {
         boolean var4 = false;

         for(Class var5 = var1.getSuperclass(); var5 != null; var5 = var5.getSuperclass()) {
            if (var5 == var2) {
               var4 = true;
            }
         }

         if (!var4) {
            throw new IntrospectionException(var2.getName() + " not superclass of " + var1.getName());
         }
      }

      if (var3 == 1) {
         this.informant = findInformant(var1);
      }

      Class var7 = var1.getSuperclass();
      if (var7 != var2) {
         int var8 = var3;
         if (var3 == 2) {
            var8 = 1;
         }

         if (var2 == null && var8 == 1) {
            this.superBeanInfo = (BeanInfo)beanInfoCache.get(var7);
            if (this.superBeanInfo == null) {
               Introspector var9 = new Introspector(var7, (Class)null, 1);
               this.superBeanInfo = var9.getBeanInfo();
               beanInfoCache.put(var7, this.superBeanInfo);
            }
         } else {
            Introspector var6 = new Introspector(var7, var2, var8);
            this.superBeanInfo = var6.getBeanInfo();
         }
      }

      if (this.informant != null) {
         this.additionalBeanInfo = this.informant.getAdditionalBeanInfo();
      }

      if (this.additionalBeanInfo == null) {
         this.additionalBeanInfo = new BeanInfo[0];
      }

   }

   private GenericBeanInfo getBeanInfo() throws IntrospectionException {
      BeanDescriptor var1 = this.getTargetBeanDescriptor();
      EventSetDescriptor[] var2 = this.getTargetEventInfo();
      int var3 = this.getTargetDefaultEventIndex();
      PropertyDescriptor[] var4 = this.getTargetPropertyInfo();
      int var5 = this.getTargetDefaultPropertyIndex();
      MethodDescriptor[] var6 = this.getTargetMethodInfo();
      return new GenericBeanInfo(var1, var2, var3, var4, var5, var6, this.informant);
   }

   private static synchronized BeanInfo findInformant(Class var0) {
      String var1 = var0.getName() + "BeanInfo";

      try {
         return (BeanInfo)instantiate(var0, var1);
      } catch (Exception var6) {
         try {
            if (isSubclass(var0, class$java$beans$BeanInfo == null ? (class$java$beans$BeanInfo = class$("java.beans.BeanInfo")) : class$java$beans$BeanInfo)) {
               return (BeanInfo)var0.newInstance();
            }
         } catch (Exception var4) {
         }

         while(var1.indexOf(46) > 0) {
            var1 = var1.substring(var1.indexOf(46) + 1);
         }

         for(int var2 = 0; var2 < searchPath.length; ++var2) {
            try {
               String var3 = searchPath[var2] + "." + var1;
               return (BeanInfo)instantiate(var0, var3);
            }
         }

         return null;
      }
   }

   private PropertyDescriptor[] getTargetPropertyInfo() throws IntrospectionException {
      PropertyDescriptor[] var1 = null;
      if (this.informant != null) {
         var1 = this.informant.getPropertyDescriptors();
         int var2 = this.informant.getDefaultPropertyIndex();
         if (var2 >= 0 && var2 < var1.length) {
            this.defaultPropertyName = var1[var2].getName();
         }
      }

      if (var1 == null && this.superBeanInfo != null) {
         PropertyDescriptor[] var14 = this.superBeanInfo.getPropertyDescriptors();

         for(int var3 = 0; var3 < var14.length; ++var3) {
            this.addProperty(var14[var3]);
         }

         int var4 = this.superBeanInfo.getDefaultPropertyIndex();
         if (var4 >= 0 && var4 < var14.length) {
            this.defaultPropertyName = var14[var4].getName();
         }
      }

      for(int var15 = 0; var15 < this.additionalBeanInfo.length; ++var15) {
         PropertyDescriptor[] var16 = this.additionalBeanInfo[var15].getPropertyDescriptors();
         if (var16 != null) {
            for(int var20 = 0; var20 < var16.length; ++var20) {
               this.addProperty(var16[var20]);
            }
         }
      }

      if (var1 != null) {
         for(int var17 = 0; var17 < var1.length; ++var17) {
            this.addProperty(var1[var17]);
         }
      } else {
         Method[] var18 = getPublicDeclaredMethods(this.beanClass);

         for(int var21 = 0; var21 < var18.length; ++var21) {
            Method var5 = var18[var21];
            if (var5 != null) {
               int var6 = var5.getModifiers();
               if (!Modifier.isStatic(var6)) {
                  String var7 = var5.getName();
                  Class[] var8 = var5.getParameterTypes();
                  Class var9 = var5.getReturnType();
                  int var10 = var8.length;
                  Object var11 = null;

                  try {
                     if (var10 == 0) {
                        if (var7.startsWith("get")) {
                           var11 = new PropertyDescriptor(decapitalize(var7.substring(3)), var5, (Method)null);
                        } else if (var9 == Boolean.TYPE && var7.startsWith("is")) {
                           var11 = new PropertyDescriptor(decapitalize(var7.substring(2)), var5, (Method)null);
                        }
                     } else if (var10 == 1) {
                        if (var8[0] == Integer.TYPE && var7.startsWith("get")) {
                           var11 = new IndexedPropertyDescriptor(decapitalize(var7.substring(3)), (Method)null, (Method)null, var5, (Method)null);
                        } else if (var9 == Void.TYPE && var7.startsWith("set")) {
                           var11 = new PropertyDescriptor(decapitalize(var7.substring(3)), (Method)null, var5);
                           if (this.throwsException(var5, class$java$beans$PropertyVetoException == null ? (class$java$beans$PropertyVetoException = class$("java.beans.PropertyVetoException")) : class$java$beans$PropertyVetoException)) {
                              ((PropertyDescriptor)var11).setConstrained(true);
                           }
                        }
                     } else if (var10 == 2 && var8[0] == Integer.TYPE && var7.startsWith("set")) {
                        var11 = new IndexedPropertyDescriptor(decapitalize(var7.substring(3)), (Method)null, (Method)null, (Method)null, var5);
                        if (this.throwsException(var5, class$java$beans$PropertyVetoException == null ? (class$java$beans$PropertyVetoException = class$("java.beans.PropertyVetoException")) : class$java$beans$PropertyVetoException)) {
                           ((PropertyDescriptor)var11).setConstrained(true);
                        }
                     }
                  } catch (IntrospectionException var13) {
                     var11 = null;
                  }

                  if (var11 != null) {
                     if (this.propertyChangeSource) {
                        ((PropertyDescriptor)var11).setBound(true);
                     }

                     this.addProperty((PropertyDescriptor)var11);
                  }
               }
            }
         }
      }

      PropertyDescriptor[] var19 = new PropertyDescriptor[this.properties.size()];
      Enumeration var22 = this.properties.elements();

      for(int var23 = 0; var23 < var19.length; ++var23) {
         var19[var23] = (PropertyDescriptor)var22.nextElement();
         if (this.defaultPropertyName != null && this.defaultPropertyName.equals(var19[var23].getName())) {
            this.defaultPropertyIndex = var23;
         }
      }

      return var19;
   }

   void addProperty(PropertyDescriptor var1) {
      String var2 = ((FeatureDescriptor)var1).getName();
      PropertyDescriptor var3 = (PropertyDescriptor)this.properties.get(var2);
      if (var3 == null) {
         this.properties.put(var2, var1);
      } else {
         Class var4 = var3.getPropertyType();
         Class var5 = var1.getPropertyType();
         if (var4 != null && var5 != null && var4 != var5) {
            if (var1.getWriteMethod() != null && var1.getReadMethod() != null || var3.getWriteMethod() == null && var1.getWriteMethod() == null || var3.getReadMethod() == null && var1.getReadMethod() == null) {
               this.properties.put(var2, var1);
            }

         } else {
            Object var6;
            if (!(var3 instanceof IndexedPropertyDescriptor) && !(var1 instanceof IndexedPropertyDescriptor)) {
               var6 = new PropertyDescriptor(var3, var1);
            } else {
               var6 = new IndexedPropertyDescriptor(var3, var1);
            }

            this.properties.put(var2, var6);
         }
      }
   }

   private EventSetDescriptor[] getTargetEventInfo() throws IntrospectionException {
      EventSetDescriptor[] var1 = null;
      if (this.informant != null) {
         var1 = this.informant.getEventSetDescriptors();
         int var2 = this.informant.getDefaultEventIndex();
         if (var2 >= 0 && var2 < var1.length) {
            this.defaultEventName = var1[var2].getName();
         }
      }

      if (var1 == null && this.superBeanInfo != null) {
         EventSetDescriptor[] var22 = this.superBeanInfo.getEventSetDescriptors();

         for(int var3 = 0; var3 < var22.length; ++var3) {
            this.addEvent(var22[var3]);
         }

         int var4 = this.superBeanInfo.getDefaultEventIndex();
         if (var4 >= 0 && var4 < var22.length) {
            this.defaultEventName = var22[var4].getName();
         }
      }

      for(int var23 = 0; var23 < this.additionalBeanInfo.length; ++var23) {
         EventSetDescriptor[] var24 = this.additionalBeanInfo[var23].getEventSetDescriptors();
         if (var24 != null) {
            for(int var28 = 0; var28 < var24.length; ++var28) {
               this.addEvent(var24[var28]);
            }
         }
      }

      if (var1 != null) {
         for(int var25 = 0; var25 < var1.length; ++var25) {
            this.addEvent(var1[var25]);
         }
      } else {
         Method[] var26 = getPublicDeclaredMethods(this.beanClass);
         Hashtable var29 = new Hashtable();
         Hashtable var5 = new Hashtable();

         for(int var6 = 0; var6 < var26.length; ++var6) {
            Method var7 = var26[var6];
            if (var7 != null) {
               int var8 = var7.getModifiers();
               if (!Modifier.isStatic(var8)) {
                  String var9 = var7.getName();
                  Class[] var10 = var7.getParameterTypes();
                  Class var11 = var7.getReturnType();
                  if (var9.startsWith("add") && var10.length == 1 && var11 == Void.TYPE) {
                     String var37 = var9.substring(3) + ":" + var10[0];
                     var29.put(var37, var7);
                  } else if (var9.startsWith("remove") && var10.length == 1 && var11 == Void.TYPE) {
                     String var12 = var9.substring(6) + ":" + var10[0];
                     var5.put(var12, var7);
                  }
               }
            }
         }

         Enumeration var32 = var29.keys();
         String var33 = this.beanClass.getName();

         while(var32.hasMoreElements()) {
            String var34 = (String)var32.nextElement();
            if (var5.get(var34) != null && var34.indexOf("Listener:") > 0) {
               String var35 = var34.substring(0, var34.indexOf(58));
               String var36 = decapitalize(var35.substring(0, var35.length() - 8));
               Method var38 = (Method)var29.get(var34);
               Method var13 = (Method)var5.get(var34);
               Class var14 = var38.getParameterTypes()[0];
               if (isSubclass(var14, eventListenerType)) {
                  Method[] var15 = var14.getMethods();
                  int var16 = 0;

                  for(int var17 = 0; var17 < var15.length; ++var17) {
                     if (this.isEventHandler(var15[var17])) {
                        ++var16;
                     } else {
                        var15[var17] = null;
                     }
                  }

                  Method[] var18 = new Method[var16];
                  int var19 = 0;

                  for(int var20 = 0; var20 < var15.length; ++var20) {
                     if (var15[var20] != null) {
                        var18[var19++] = var15[var20];
                     }
                  }

                  EventSetDescriptor var21 = new EventSetDescriptor(var36, var14, var18, var38, var13);
                  if (this.throwsException(var38, class$java$util$TooManyListenersException == null ? (class$java$util$TooManyListenersException = class$("java.util.TooManyListenersException")) : class$java$util$TooManyListenersException)) {
                     var21.setUnicast(true);
                  }

                  this.addEvent(var21);
               }
            }
         }
      }

      EventSetDescriptor[] var27 = new EventSetDescriptor[this.events.size()];
      Enumeration var30 = this.events.elements();

      for(int var31 = 0; var31 < var27.length; ++var31) {
         var27[var31] = (EventSetDescriptor)var30.nextElement();
         if (this.defaultEventName != null && this.defaultEventName.equals(var27[var31].getName())) {
            this.defaultEventIndex = var31;
         }
      }

      return var27;
   }

   void addEvent(EventSetDescriptor var1) {
      String var2 = ((FeatureDescriptor)var1).getName() + var1.getListenerType();
      if (((FeatureDescriptor)var1).getName().equals("propertyChange")) {
         this.propertyChangeSource = true;
      }

      EventSetDescriptor var3 = (EventSetDescriptor)this.events.get(var2);
      if (var3 == null) {
         this.events.put(var2, var1);
      } else {
         EventSetDescriptor var4 = new EventSetDescriptor(var3, var1);
         this.events.put(var2, var4);
      }
   }

   private MethodDescriptor[] getTargetMethodInfo() throws IntrospectionException {
      MethodDescriptor[] var1 = null;
      if (this.informant != null) {
         var1 = this.informant.getMethodDescriptors();
      }

      if (var1 == null && this.superBeanInfo != null) {
         MethodDescriptor[] var2 = this.superBeanInfo.getMethodDescriptors();

         for(int var3 = 0; var3 < var2.length; ++var3) {
            this.addMethod(var2[var3]);
         }
      }

      for(int var7 = 0; var7 < this.additionalBeanInfo.length; ++var7) {
         MethodDescriptor[] var8 = this.additionalBeanInfo[var7].getMethodDescriptors();
         if (var8 != null) {
            for(int var4 = 0; var4 < var8.length; ++var4) {
               this.addMethod(var8[var4]);
            }
         }
      }

      if (var1 != null) {
         for(int var9 = 0; var9 < var1.length; ++var9) {
            this.addMethod(var1[var9]);
         }
      } else {
         Method[] var10 = getPublicDeclaredMethods(this.beanClass);

         for(int var12 = 0; var12 < var10.length; ++var12) {
            Method var5 = var10[var12];
            if (var5 != null) {
               MethodDescriptor var6 = new MethodDescriptor(var5);
               this.addMethod(var6);
            }
         }
      }

      MethodDescriptor[] var11 = new MethodDescriptor[this.methods.size()];
      Enumeration var13 = this.methods.elements();

      for(int var14 = 0; var14 < var11.length; ++var14) {
         var11[var14] = (MethodDescriptor)var13.nextElement();
      }

      return var11;
   }

   private void addMethod(MethodDescriptor var1) {
      String var2 = var1.getMethod().getName();
      MethodDescriptor var3 = (MethodDescriptor)this.methods.get(var2);
      if (var3 == null) {
         this.methods.put(var2, var1);
      } else {
         Class[] var4 = var1.getMethod().getParameterTypes();
         Class[] var5 = var3.getMethod().getParameterTypes();
         boolean var6 = false;
         if (var4.length == var5.length) {
            var6 = true;

            for(int var7 = 0; var7 < var4.length; ++var7) {
               if (var4[var7] != var5[var7]) {
                  var6 = false;
                  break;
               }
            }
         }

         if (var6) {
            MethodDescriptor var11 = new MethodDescriptor(var3, var1);
            this.methods.put(var2, var11);
         } else {
            String var10 = this.makeQualifiedMethodName(var1);
            var3 = (MethodDescriptor)this.methods.get(var10);
            if (var3 == null) {
               this.methods.put(var10, var1);
            } else {
               MethodDescriptor var8 = new MethodDescriptor(var3, var1);
               this.methods.put(var10, var8);
            }
         }
      }
   }

   private String makeQualifiedMethodName(MethodDescriptor var1) {
      Method var2 = var1.getMethod();
      StringBuffer var3 = new StringBuffer();
      var3.append(var2.getName());
      var3.append("=");
      Class[] var4 = var2.getParameterTypes();

      for(int var5 = 0; var5 < var4.length; ++var5) {
         var3.append(":");
         var3.append(var4[var5].getName());
      }

      return var3.toString();
   }

   private int getTargetDefaultEventIndex() {
      return this.defaultEventIndex;
   }

   private int getTargetDefaultPropertyIndex() {
      return this.defaultPropertyIndex;
   }

   private BeanDescriptor getTargetBeanDescriptor() throws IntrospectionException {
      if (this.informant != null) {
         BeanDescriptor var1 = this.informant.getBeanDescriptor();
         if (var1 != null) {
            return var1;
         }
      }

      return new BeanDescriptor(this.beanClass);
   }

   private boolean isEventHandler(Method var1) throws IntrospectionException {
      try {
         Class[] var2 = var1.getParameterTypes();
         if (var2.length != 1) {
            return false;
         } else {
            return isSubclass(var2[0], class$java$util$EventObject == null ? (class$java$util$EventObject = class$("java.util.EventObject")) : class$java$util$EventObject);
         }
      } catch (Exception var3) {
         throw new IntrospectionException("Unexpected reflection exception: " + var3);
      }
   }

   private static synchronized Method[] getPublicDeclaredMethods(Class var0) {
      Method[] var2 = (Method[])declaredMethodCache.get(var0);
      if (var2 != null) {
         return var2;
      } else {
         var2 = (Method[])AccessController.doPrivileged(new 1(var0));

         for(int var3 = 0; var3 < var2.length; ++var3) {
            Method var4 = var2[var3];
            int var5 = var4.getModifiers();
            if (!Modifier.isPublic(var5)) {
               var2[var3] = null;
            }
         }

         declaredMethodCache.put(var0, var2);
         return var2;
      }
   }

   private static Method internalFindMethod(Class var0, String var1, int var2) {
      for(Class var3 = var0; var3 != null; var3 = var3.getSuperclass()) {
         Method[] var4 = getPublicDeclaredMethods(var3);

         for(int var5 = 0; var5 < var4.length; ++var5) {
            Method var6 = var4[var5];
            if (var6 != null) {
               int var7 = var6.getModifiers();
               if (!Modifier.isStatic(var7) && var6.getName().equals(var1) && var6.getParameterTypes().length == var2) {
                  return var6;
               }
            }
         }
      }

      Class[] var8 = var0.getInterfaces();

      for(int var9 = 0; var9 < var8.length; ++var9) {
         Method var10 = internalFindMethod(var8[var9], var1, var2);
         if (var10 != null) {
            return var10;
         }
      }

      return null;
   }

   private static Method internalFindMethod(Class var0, String var1, int var2, Class[] var3) {
      for(Class var4 = var0; var4 != null; var4 = var4.getSuperclass()) {
         Method[] var5 = getPublicDeclaredMethods(var4);

         for(int var6 = 0; var6 < var5.length; ++var6) {
            Method var7 = var5[var6];
            if (var7 != null) {
               int var8 = var7.getModifiers();
               if (!Modifier.isStatic(var8)) {
                  Class[] var9 = var7.getParameterTypes();
                  if (var7.getName().equals(var1) && var9.length == var2) {
                     boolean var10 = false;
                     if (var2 <= 0) {
                        return var7;
                     }

                     for(int var11 = 0; var11 < var2; ++var11) {
                        if (var9[var11] != var3[var11]) {
                           var10 = true;
                        }
                     }

                     if (!var10) {
                        return var7;
                     }
                  }
               }
            }
         }
      }

      Class[] var12 = var0.getInterfaces();

      for(int var13 = 0; var13 < var12.length; ++var13) {
         Method var14 = internalFindMethod(var12[var13], var1, var2);
         if (var14 != null) {
            return var14;
         }
      }

      return null;
   }

   static Method findMethod(Class var0, String var1, int var2) throws IntrospectionException {
      if (var1 == null) {
         return null;
      } else {
         Method var3 = internalFindMethod(var0, var1, var2);
         if (var3 != null) {
            return var3;
         } else {
            throw new IntrospectionException("No method \"" + var1 + "\" with " + var2 + " arg(s)");
         }
      }
   }

   static Method findMethod(Class var0, String var1, int var2, Class[] var3) throws IntrospectionException {
      if (var1 == null) {
         return null;
      } else {
         Method var4 = internalFindMethod(var0, var1, var2, var3);
         if (var4 != null) {
            return var4;
         } else {
            throw new IntrospectionException("No method \"" + var1 + "\" with " + var2 + " arg(s) of matching types.");
         }
      }
   }

   static boolean isSubclass(Class var0, Class var1) {
      if (var0 == var1) {
         return true;
      } else if (var0 != null && var1 != null) {
         for(Class var2 = var0; var2 != null; var2 = var2.getSuperclass()) {
            if (var2 == var1) {
               return true;
            }

            if (var1.isInterface()) {
               Class[] var3 = var2.getInterfaces();

               for(int var4 = 0; var4 < var3.length; ++var4) {
                  if (isSubclass(var3[var4], var1)) {
                     return true;
                  }
               }
            }
         }

         return false;
      } else {
         return false;
      }
   }

   private boolean throwsException(Method var1, Class var2) {
      Class[] var3 = var1.getExceptionTypes();

      for(int var4 = 0; var4 < var3.length; ++var4) {
         if (var3[var4] == var2) {
            return true;
         }
      }

      return false;
   }

   static Object instantiate(Class var0, String var1) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
      ClassLoader var2 = var0.getClassLoader();
      if (var2 != null) {
         try {
            Class var8 = var2.loadClass(var1);
            return var8.newInstance();
         } catch (Exception var5) {
         }
      }

      try {
         var2 = ClassLoader.getSystemClassLoader();
         if (var2 != null) {
            Class var7 = var2.loadClass(var1);
            return var7.newInstance();
         }
      } catch (Exception var4) {
      }

      Class var3 = Class.forName(var1);
      return var3.newInstance();
   }

   // $FF: synthetic method
   static Class class$(String var0) {
      try {
         return Class.forName(var0);
      } catch (ClassNotFoundException var2) {
         throw new NoClassDefFoundError(((Throwable)var2).getMessage());
      }
   }

   static {
      eventListenerType = class$java$util$EventListener == null ? (class$java$util$EventListener = class$("java.util.EventListener")) : class$java$util$EventListener;
      declaredMethodCache = new Hashtable();
      searchPath = new String[]{"sun.beans.infos"};
   }
}