libjava/classpath/test/base/OutputClass.java

   1 import java.io.*;
   2 import gnu.java.lang.*;
   3 import java.lang.reflect.*;
   4
   5 public class OutputClass {
   6         public static void main(String[] args) {
   7                 for(int i=1;i<args.length;i++) {
   8                         if(args[i].endsWith(".class")) {
   9                                 args[i] = args[i].substring(0,args[i].length()-6);
  10                         }
  11                         args[i] = args[i].replace('/','.');
  12                         try {
  13                         try {
  14                                 OutputClass.outputClass(Class.forName(args[i]),System.out);
  15                         } catch(ClassNotFoundException E) {
  16                                 new PrintStream(new FileOutputStream(args[i]+".out-"+args[0])).println(args[i] + ": class missing.");
  17                         }
  18                         } catch(IOException e) {
  19                         }
  20                 }
  21         }
  22
  23         static void outputClass(Class c, PrintStream out) {
  24                 out.println(c.getName() + ":class:" + Modifier.toString(sanitizeModifier(c.getModifiers())));
  25                 // Put implemented interfaces here
  26                 Field[] f = ClassHelper.getAllFields(c);
  27                 for(int i=0;i<f.length;i++) {
  28                         if(Modifier.isPublic(f[i].getModifiers()) || Modifier.isProtected(f[i].getModifiers())) {
  29                                 out.println(
  30                                   c.getName()
  31                                   + ":field:"
  32                                   + Modifier.toString(sanitizeModifier(f[i].getModifiers()))
  33                                   + " "
  34                                   + f[i].getType().getName()
  35                                   + " "
  36                                   + ClassHelper.getTruncatedName(f[i].getName()));
  37                         }
  38                 }
  39
  40                 Method[] m = ClassHelper.getAllMethods(c);
  41                 for(int i=0;i<m.length;i++) {
  42                         if(Modifier.isPublic(m[i].getModifiers()) || Modifier.isProtected(m[i].getModifiers())) {
  43                                 out.println(
  44                                   c.getName()
  45                                   + ":method:"
  46                                   + Modifier.toString(sanitizeModifier(m[i].getModifiers()))
  47                                   + " "
  48                                   + m[i].getReturnType().getName()
  49                                   + " "
  50                                   + ClassHelper.getTruncatedName(m[i].getName())
  51                                   + "("
  52                                   + printArgs(m[i].getParameterTypes())
  53                                   + ")"
  54                                   + printExceptions(m[i].getExceptionTypes()));
  55                         }
  56                 }
  57
  58                 Constructor[] cl = c.getDeclaredConstructors();
  59                 for(int i=0;i<cl.length;i++) {
  60                         if(Modifier.isPublic(cl[i].getModifiers()) || Modifier.isProtected(cl[i].getModifiers())) {
  61                                 out.println(
  62                                   c.getName()
  63                                   + ":constructor:"
  64                                   + Modifier.toString(sanitizeModifier(cl[i].getModifiers()))
  65                                   + " "
  66                                   + ClassHelper.getTruncatedName(cl[i].getName())
  67                                   + "("
  68                                   + printArgs(cl[i].getParameterTypes())
  69                                   + ")"
  70                                   + printExceptions(m[i].getExceptionTypes()));
  71                         }
  72                 }
  73         }
  74
  75         static String printArgs(Class[] args) {
  76                 StringBuffer sb = new StringBuffer();
  77                 for(int i=0;i<args.length;i++) {
  78                         sb.append(args[i]);
  79                         if(i!=args.length-1) {
  80                                 sb.append(",");
  81                         }
  82                 }
  83                 return sb.toString();
  84         }
  85
  86         static String printExceptions(Class[] exceptions) {
  87                 StringBuffer sb = new StringBuffer();
  88                 for(int i=0;i<exceptions.length;i++) {
  89                         sb.append(" ");
  90                         sb.append(exceptions[i].getName());
  91                 }
  92                 return sb.toString();
  93         }
  94
  95         static int sanitizeModifier(int modifier) {
  96                 return modifier & ~(Modifier.SYNCHRONIZED | Modifier.TRANSIENT | Modifier.VOLATILE | Modifier.NATIVE);
  97         }
  98 }