tools/dexdeps/src/com/android/dexdeps/Output.java - platform/dalvik - Git at Google

 /*
  * Copyright (C) 2009 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.dexdeps;

 import java.io.PrintStream;

 /**
  * Generate fancy output.
  */
 public class Output {
     private static final String IN0 = "";
     private static final String IN1 = "  ";
     private static final String IN2 = "    ";
     private static final String IN3 = "      ";
     private static final String IN4 = "        ";

     private static final PrintStream out = System.out;

     private static void generateHeader0(String fileName, String format) {
         if (format.equals("brief")) {
             if (fileName != null) {
                 out.println("File: " + fileName);
             }
         } else if (format.equals("xml")) {
             if (fileName != null) {
                 out.println(IN0 + "<external file=\"" + fileName + "\">");
             } else {
                 out.println(IN0 + "<external>");
             }
         } else {
             /* should've been trapped in arg handler */
             throw new RuntimeException("unknown output format");
         }
     }

     public static void generateFirstHeader(String fileName, String format) {
         generateHeader0(fileName, format);
     }

     public static void generateHeader(String fileName, String format) {
         out.println();
         generateHeader0(fileName, format);
     }

     public static void generateFooter(String format) {
         if (format.equals("brief")) {
             // Nothing to do.
         } else if (format.equals("xml")) {
             out.println("</external>");
         } else {
             /* should've been trapped in arg handler */
             throw new RuntimeException("unknown output format");
         }
     }

     public static void generate(DexData dexData, String format,
             boolean justClasses) {
         if (format.equals("brief")) {
             printBrief(dexData, justClasses);
         } else if (format.equals("xml")) {
             printXml(dexData, justClasses);
         } else {
             /* should've been trapped in arg handler */
             throw new RuntimeException("unknown output format");
         }
     }

     /**
      * Prints the data in a simple human-readable format.
      */
     static void printBrief(DexData dexData, boolean justClasses) {
         ClassRef[] externClassRefs = dexData.getExternalReferences();

         printClassRefs(externClassRefs, justClasses);

         if (!justClasses) {
             printFieldRefs(externClassRefs);
             printMethodRefs(externClassRefs);
         }
     }

     /**
      * Prints the list of classes in a simple human-readable format.
      */
     static void printClassRefs(ClassRef[] classes, boolean justClasses) {
         if (!justClasses) {
             out.println("Classes:");
         }

         for (int i = 0; i < classes.length; i++) {
             ClassRef ref = classes[i];

             out.println(descriptorToDot(ref.getName()));
         }
     }

     /**
      * Prints the list of fields in a simple human-readable format.
      */
     static void printFieldRefs(ClassRef[] classes) {
         out.println("\nFields:");
         for (int i = 0; i < classes.length; i++) {
             FieldRef[] fields = classes[i].getFieldArray();

             for (int j = 0; j < fields.length; j++) {
                 FieldRef ref = fields[j];

                 out.println(descriptorToDot(ref.getDeclClassName()) +
                     "." + ref.getName() + " : " + ref.getTypeName());
             }
         }
     }

     /**
      * Prints the list of methods in a simple human-readable format.
      */
     static void printMethodRefs(ClassRef[] classes) {
         out.println("\nMethods:");
         for (int i = 0; i < classes.length; i++) {
             MethodRef[] methods = classes[i].getMethodArray();

             for (int j = 0; j < methods.length; j++) {
                 MethodRef ref = methods[j];

                 out.println(descriptorToDot(ref.getDeclClassName()) +
                     "." + ref.getName() + " : " + ref.getDescriptor());
             }
         }
     }

     /**
      * Prints the output in XML format.
      *
      * We shouldn't need to XML-escape the field/method info.
      */
     static void printXml(DexData dexData, boolean justClasses) {
         ClassRef[] externClassRefs = dexData.getExternalReferences();

         /*
          * Iterate through externClassRefs.  For each class, dump all of
          * the matching fields and methods.
          */
         String prevPackage = null;
         for (int i = 0; i < externClassRefs.length; i++) {
             ClassRef cref = externClassRefs[i];
             String declClassName = cref.getName();
             String className = classNameOnly(declClassName);
             String packageName = packageNameOnly(declClassName);

             /*
              * If we're in a different package, emit the appropriate tags.
              */
             if (!packageName.equals(prevPackage)) {
                 if (prevPackage != null) {
                     out.println(IN1 + "</package>");
                 }

                 out.println(IN1 +
                     "<package name=\"" + packageName + "\">");

                 prevPackage = packageName;
             }

             out.println(IN2 + "<class name=\"" + className + "\">");
             if (!justClasses) {
                 printXmlFields(cref);
                 printXmlMethods(cref);
             }
             out.println(IN2 + "</class>");
         }

         if (prevPackage != null)
             out.println(IN1 + "</package>");
     }

     /**
      * Prints the externally-visible fields in XML format.
      */
     private static void printXmlFields(ClassRef cref) {
         FieldRef[] fields = cref.getFieldArray();
         for (int i = 0; i < fields.length; i++) {
             FieldRef fref = fields[i];

             out.println(IN3 + "<field name=\"" + fref.getName() +
                 "\" type=\"" + descriptorToDot(fref.getTypeName()) + "\"/>");
         }
     }

     /**
      * Prints the externally-visible methods in XML format.
      */
     private static void printXmlMethods(ClassRef cref) {
         MethodRef[] methods = cref.getMethodArray();
         for (int i = 0; i < methods.length; i++) {
             MethodRef mref = methods[i];
             String declClassName = mref.getDeclClassName();
             boolean constructor;

             constructor = mref.getName().equals("<init>");
             if (constructor) {
                 // use class name instead of method name
                 out.println(IN3 + "<constructor name=\"" +
                     classNameOnly(declClassName) + "\">");
             } else {
                 out.println(IN3 + "<method name=\"" + mref.getName() +
                     "\" return=\"" + descriptorToDot(mref.getReturnTypeName()) +
                     "\">");
             }
             String[] args = mref.getArgumentTypeNames();
             for (int j = 0; j < args.length; j++) {
                 out.println(IN4 + "<parameter type=\"" +
                     descriptorToDot(args[j]) + "\"/>");
             }
             if (constructor) {
                 out.println(IN3 + "</constructor>");
             } else {
                 out.println(IN3 + "</method>");
             }
         }
     }


     /*
      * =======================================================================
      *      Utility functions
      * =======================================================================
      */

     /**
      * Converts a single-character primitive type into its human-readable
      * equivalent.
      */
     static String primitiveTypeLabel(char typeChar) {
         /* primitive type; substitute human-readable name in */
         switch (typeChar) {
             case 'B':   return "byte";
             case 'C':   return "char";
             case 'D':   return "double";
             case 'F':   return "float";
             case 'I':   return "int";
             case 'J':   return "long";
             case 'S':   return "short";
             case 'V':   return "void";
             case 'Z':   return "boolean";
             default:
                 /* huh? */
                 System.err.println("Unexpected class char " + typeChar);
                 assert false;
                 return "UNKNOWN";
         }
     }

     /**
      * Converts a type descriptor to human-readable "dotted" form.  For
      * example, "Ljava/lang/String;" becomes "java.lang.String", and
      * "[I" becomes "int[].
      */
     static String descriptorToDot(String descr) {
         int targetLen = descr.length();
         int offset = 0;
         int arrayDepth = 0;

         /* strip leading [s; will be added to end */
         while (targetLen > 1 && descr.charAt(offset) == '[') {
             offset++;
             targetLen--;
         }
         arrayDepth = offset;

         if (targetLen == 1) {
             descr = primitiveTypeLabel(descr.charAt(offset));
             offset = 0;
             targetLen = descr.length();
         } else {
             /* account for leading 'L' and trailing ';' */
             if (targetLen >= 2 && descr.charAt(offset) == 'L' &&
                 descr.charAt(offset+targetLen-1) == ';')
             {
                 targetLen -= 2;     /* two fewer chars to copy */
                 offset++;           /* skip the 'L' */
             }
         }

         char[] buf = new char[targetLen + arrayDepth * 2];

         /* copy class name over */
         int i;
         for (i = 0; i < targetLen; i++) {
             char ch = descr.charAt(offset + i);
             buf[i] = (ch == '/') ? '.' : ch;
         }

         /* add the appopriate number of brackets for arrays */
         while (arrayDepth-- > 0) {
             buf[i++] = '[';
             buf[i++] = ']';
         }
         assert i == buf.length;

         return new String(buf);
     }

     /**
      * Extracts the class name from a type descriptor.
      */
     static String classNameOnly(String typeName) {
         String dotted = descriptorToDot(typeName);

         int start = dotted.lastIndexOf(".");
         if (start < 0) {
             return dotted;
         } else {
             return dotted.substring(start+1);
         }
     }

     /**
      * Extracts the package name from a type descriptor, and returns it in
      * dotted form.
      */
     static String packageNameOnly(String typeName) {
         String dotted = descriptorToDot(typeName);

         int end = dotted.lastIndexOf(".");
         if (end < 0) {
             /* lives in default package */
             return "";
         } else {
             return dotted.substring(0, end);
         }
     }
 }
	/*
	* Copyright (C) 2009 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.dexdeps;

	import java.io.PrintStream;

	/**
	* Generate fancy output.
	*/
	public class Output {
	private static final String IN0 = "";
	private static final String IN1 = " ";
	private static final String IN2 = " ";
	private static final String IN3 = " ";
	private static final String IN4 = " ";

	private static final PrintStream out = System.out;

	private static void generateHeader0(String fileName, String format) {
	if (format.equals("brief")) {
	if (fileName != null) {
	out.println("File: " + fileName);
	}
	} else if (format.equals("xml")) {
	if (fileName != null) {
	out.println(IN0 + "<external file=\"" + fileName + "\">");
	} else {
	out.println(IN0 + "<external>");
	}
	} else {
	/* should've been trapped in arg handler */
	throw new RuntimeException("unknown output format");
	}
	}

	public static void generateFirstHeader(String fileName, String format) {
	generateHeader0(fileName, format);
	}

	public static void generateHeader(String fileName, String format) {
	out.println();
	generateHeader0(fileName, format);
	}

	public static void generateFooter(String format) {
	if (format.equals("brief")) {
	// Nothing to do.
	} else if (format.equals("xml")) {
	out.println("</external>");
	} else {
	/* should've been trapped in arg handler */
	throw new RuntimeException("unknown output format");
	}
	}

	public static void generate(DexData dexData, String format,
	boolean justClasses) {
	if (format.equals("brief")) {
	printBrief(dexData, justClasses);
	} else if (format.equals("xml")) {
	printXml(dexData, justClasses);
	} else {
	/* should've been trapped in arg handler */
	throw new RuntimeException("unknown output format");
	}
	}

	/**
	* Prints the data in a simple human-readable format.
	*/
	static void printBrief(DexData dexData, boolean justClasses) {
	ClassRef[] externClassRefs = dexData.getExternalReferences();

	printClassRefs(externClassRefs, justClasses);

	if (!justClasses) {
	printFieldRefs(externClassRefs);
	printMethodRefs(externClassRefs);
	}
	}

	/**
	* Prints the list of classes in a simple human-readable format.
	*/
	static void printClassRefs(ClassRef[] classes, boolean justClasses) {
	if (!justClasses) {
	out.println("Classes:");
	}

	for (int i = 0; i < classes.length; i++) {
	ClassRef ref = classes[i];

	out.println(descriptorToDot(ref.getName()));
	}
	}

	/**
	* Prints the list of fields in a simple human-readable format.
	*/
	static void printFieldRefs(ClassRef[] classes) {
	out.println("\nFields:");
	for (int i = 0; i < classes.length; i++) {
	FieldRef[] fields = classes[i].getFieldArray();

	for (int j = 0; j < fields.length; j++) {
	FieldRef ref = fields[j];

	out.println(descriptorToDot(ref.getDeclClassName()) +
	"." + ref.getName() + " : " + ref.getTypeName());
	}
	}
	}

	/**
	* Prints the list of methods in a simple human-readable format.
	*/
	static void printMethodRefs(ClassRef[] classes) {
	out.println("\nMethods:");
	for (int i = 0; i < classes.length; i++) {
	MethodRef[] methods = classes[i].getMethodArray();

	for (int j = 0; j < methods.length; j++) {
	MethodRef ref = methods[j];

	out.println(descriptorToDot(ref.getDeclClassName()) +
	"." + ref.getName() + " : " + ref.getDescriptor());
	}
	}
	}

	/**
	* Prints the output in XML format.
	*
	* We shouldn't need to XML-escape the field/method info.
	*/
	static void printXml(DexData dexData, boolean justClasses) {
	ClassRef[] externClassRefs = dexData.getExternalReferences();

	/*
	* Iterate through externClassRefs. For each class, dump all of
	* the matching fields and methods.
	*/
	String prevPackage = null;
	for (int i = 0; i < externClassRefs.length; i++) {
	ClassRef cref = externClassRefs[i];
	String declClassName = cref.getName();
	String className = classNameOnly(declClassName);
	String packageName = packageNameOnly(declClassName);

	/*
	* If we're in a different package, emit the appropriate tags.
	*/
	if (!packageName.equals(prevPackage)) {
	if (prevPackage != null) {
	out.println(IN1 + "</package>");
	}

	out.println(IN1 +
	"<package name=\"" + packageName + "\">");

	prevPackage = packageName;
	}

	out.println(IN2 + "<class name=\"" + className + "\">");
	if (!justClasses) {
	printXmlFields(cref);
	printXmlMethods(cref);
	}
	out.println(IN2 + "</class>");
	}

	if (prevPackage != null)
	out.println(IN1 + "</package>");
	}

	/**
	* Prints the externally-visible fields in XML format.
	*/
	private static void printXmlFields(ClassRef cref) {
	FieldRef[] fields = cref.getFieldArray();
	for (int i = 0; i < fields.length; i++) {
	FieldRef fref = fields[i];

	out.println(IN3 + "<field name=\"" + fref.getName() +
	"\" type=\"" + descriptorToDot(fref.getTypeName()) + "\"/>");
	}
	}

	/**
	* Prints the externally-visible methods in XML format.
	*/
	private static void printXmlMethods(ClassRef cref) {
	MethodRef[] methods = cref.getMethodArray();
	for (int i = 0; i < methods.length; i++) {
	MethodRef mref = methods[i];
	String declClassName = mref.getDeclClassName();
	boolean constructor;

	constructor = mref.getName().equals("<init>");
	if (constructor) {
	// use class name instead of method name
	out.println(IN3 + "<constructor name=\"" +
	classNameOnly(declClassName) + "\">");
	} else {
	out.println(IN3 + "<method name=\"" + mref.getName() +
	"\" return=\"" + descriptorToDot(mref.getReturnTypeName()) +
	"\">");
	}
	String[] args = mref.getArgumentTypeNames();
	for (int j = 0; j < args.length; j++) {
	out.println(IN4 + "<parameter type=\"" +
	descriptorToDot(args[j]) + "\"/>");
	}
	if (constructor) {
	out.println(IN3 + "</constructor>");
	} else {
	out.println(IN3 + "</method>");
	}
	}
	}


	/*
	* =======================================================================
	* Utility functions
	* =======================================================================
	*/

	/**
	* Converts a single-character primitive type into its human-readable
	* equivalent.
	*/
	static String primitiveTypeLabel(char typeChar) {
	/* primitive type; substitute human-readable name in */
	switch (typeChar) {
	case 'B': return "byte";
	case 'C': return "char";
	case 'D': return "double";
	case 'F': return "float";
	case 'I': return "int";
	case 'J': return "long";
	case 'S': return "short";
	case 'V': return "void";
	case 'Z': return "boolean";
	default:
	/* huh? */
	System.err.println("Unexpected class char " + typeChar);
	assert false;
	return "UNKNOWN";
	}
	}

	/**
	* Converts a type descriptor to human-readable "dotted" form. For
	* example, "Ljava/lang/String;" becomes "java.lang.String", and
	* "[I" becomes "int[].
	*/
	static String descriptorToDot(String descr) {
	int targetLen = descr.length();
	int offset = 0;
	int arrayDepth = 0;

	/* strip leading [s; will be added to end */
	while (targetLen > 1 && descr.charAt(offset) == '[') {
	offset++;
	targetLen--;
	}
	arrayDepth = offset;

	if (targetLen == 1) {
	descr = primitiveTypeLabel(descr.charAt(offset));
	offset = 0;
	targetLen = descr.length();
	} else {
	/* account for leading 'L' and trailing ';' */
	if (targetLen >= 2 && descr.charAt(offset) == 'L' &&
	descr.charAt(offset+targetLen-1) == ';')
	{
	targetLen -= 2; /* two fewer chars to copy */
	offset++; /* skip the 'L' */
	}
	}

	char[] buf = new char[targetLen + arrayDepth * 2];

	/* copy class name over */
	int i;
	for (i = 0; i < targetLen; i++) {
	char ch = descr.charAt(offset + i);
	buf[i] = (ch == '/') ? '.' : ch;
	}

	/* add the appopriate number of brackets for arrays */
	while (arrayDepth-- > 0) {
	buf[i++] = '[';
	buf[i++] = ']';
	}
	assert i == buf.length;

	return new String(buf);
	}

	/**
	* Extracts the class name from a type descriptor.
	*/
	static String classNameOnly(String typeName) {
	String dotted = descriptorToDot(typeName);

	int start = dotted.lastIndexOf(".");
	if (start < 0) {
	return dotted;
	} else {
	return dotted.substring(start+1);
	}
	}

	/**
	* Extracts the package name from a type descriptor, and returns it in
	* dotted form.
	*/
	static String packageNameOnly(String typeName) {
	String dotted = descriptorToDot(typeName);

	int end = dotted.lastIndexOf(".");
	if (end < 0) {
	/* lives in default package */
	return "";
	} else {
	return dotted.substring(0, end);
	}
	}
	}