90             i[0] = endc+1;
  91             String name = str.substring(begc, endc).replace('/', '.');
  92             try {
  93                 return (loader == null)
  94                     ? Class.forName(name, false, null)
  95                     : loader.loadClass(name);
  96             } catch (ClassNotFoundException ex) {
  97                 throw new TypeNotPresentException(name, ex);
  98             }
  99         } else if (c == '[') {
 100             Class<?> t = parseSig(str, i, end, loader);
 101             if (t != null)
 102                 t = java.lang.reflect.Array.newInstance(t, 0).getClass();
 103             return t;
 104         } else {
 105             return Wrapper.forBasicType(c).primitiveType();
 106         }
 107     }
 108 
 109     public static String unparse(Class<?> type) {





 110         StringBuilder sb = new StringBuilder();
 111         unparseSig(type, sb);
 112         return sb.toString();
 113     }
 114 
 115     public static String unparse(MethodType type) {
 116         return unparseMethod(type.returnType(), type.parameterArray());
 117     }
 118 
 119     public static String unparse(Object type) {
 120         if (type instanceof Class<?>)
 121             return unparse((Class<?>) type);
 122         if (type instanceof MethodType)
 123             return unparse((MethodType) type);
 124         return (String) type;
 125     }
 126 
 127     public static String unparseMethod(Class<?> rtype, List<Class<?>> ptypes) {
 128         StringBuilder sb = new StringBuilder();
 129         sb.append('(');

 131             unparseSig(pt, sb);
 132         sb.append(')');
 133         unparseSig(rtype, sb);
 134         return sb.toString();
 135     }
 136 
 137     public static String unparseMethod(Class<?> rtype, Class<?>[] ptypes) {
 138         StringBuilder sb = new StringBuilder();
 139         sb.append('(');
 140         for (Class<?> pt : ptypes)
 141             unparseSig(pt, sb);
 142         sb.append(')');
 143         unparseSig(rtype, sb);
 144         return sb.toString();
 145     }
 146 
 147     private static void unparseSig(Class<?> t, StringBuilder sb) {
 148         char c = Wrapper.forBasicType(t).basicTypeChar();
 149         if (c != 'L') {
 150             sb.append(c);


 151         } else {
 152             boolean lsemi = (!t.isArray());
 153             if (lsemi)  sb.append('L');
 154             sb.append(t.getName().replace('.', '/'));
 155             if (lsemi)  sb.append(';');
 156         }
 157     }
 158 
 159 }

  90             i[0] = endc+1;
  91             String name = str.substring(begc, endc).replace('/', '.');
  92             try {
  93                 return (loader == null)
  94                     ? Class.forName(name, false, null)
  95                     : loader.loadClass(name);
  96             } catch (ClassNotFoundException ex) {
  97                 throw new TypeNotPresentException(name, ex);
  98             }
  99         } else if (c == '[') {
 100             Class<?> t = parseSig(str, i, end, loader);
 101             if (t != null)
 102                 t = java.lang.reflect.Array.newInstance(t, 0).getClass();
 103             return t;
 104         } else {
 105             return Wrapper.forBasicType(c).primitiveType();
 106         }
 107     }
 108 
 109     public static String unparse(Class<?> type) {
 110         if (type == Object.class) {
 111             return "Ljava/lang/Object;";
 112         } else if (type == int.class) {
 113             return "I";
 114         }
 115         StringBuilder sb = new StringBuilder();
 116         unparseSig(type, sb);
 117         return sb.toString();
 118     }
 119 
 120     public static String unparse(MethodType type) {
 121         return unparseMethod(type.returnType(), type.parameterArray());
 122     }
 123 
 124     public static String unparse(Object type) {
 125         if (type instanceof Class<?>)
 126             return unparse((Class<?>) type);
 127         if (type instanceof MethodType)
 128             return unparse((MethodType) type);
 129         return (String) type;
 130     }
 131 
 132     public static String unparseMethod(Class<?> rtype, List<Class<?>> ptypes) {
 133         StringBuilder sb = new StringBuilder();
 134         sb.append('(');

 136             unparseSig(pt, sb);
 137         sb.append(')');
 138         unparseSig(rtype, sb);
 139         return sb.toString();
 140     }
 141 
 142     public static String unparseMethod(Class<?> rtype, Class<?>[] ptypes) {
 143         StringBuilder sb = new StringBuilder();
 144         sb.append('(');
 145         for (Class<?> pt : ptypes)
 146             unparseSig(pt, sb);
 147         sb.append(')');
 148         unparseSig(rtype, sb);
 149         return sb.toString();
 150     }
 151 
 152     private static void unparseSig(Class<?> t, StringBuilder sb) {
 153         char c = Wrapper.forBasicType(t).basicTypeChar();
 154         if (c != 'L') {
 155             sb.append(c);
 156         } else if (t == Object.class) {
 157             sb.append("Ljava/lang/Object;");
 158         } else {
 159             boolean lsemi = (!t.isArray());
 160             if (lsemi)  sb.append('L');
 161             sb.append(t.getName().replace('.', '/'));
 162             if (lsemi)  sb.append(';');
 163         }
 164     }
 165 
 166 }