make/modules/tools/src/com/sun/classanalyzer/ClassAnalyzer.java - toolchain/jdk/jdk9_jdk - Git at Google

 /*
  * Copyright (c) 2009, 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.
  *
  * 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 com.sun.classanalyzer;

 import com.sun.classanalyzer.AnnotatedDependency.*;
 import com.sun.classanalyzer.Module.Dependency;
 import com.sun.classanalyzer.Module.PackageInfo;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 import java.io.File;
 import java.io.PrintWriter;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeMap;
 import java.util.TreeSet;

 /**
  *
  * @author Mandy Chung
  */
 public class ClassAnalyzer {

     public static void main(String[] args) throws Exception {
         String jdkhome = null;
         String cpath = null;
         List<String> configs = new ArrayList<String>();
         List<String> depconfigs = new ArrayList<String>();
         String output = ".";
         boolean mergeModules = true;
         boolean showDynamic = false;

         // process arguments
         int i = 0;
         while (i < args.length) {
             String arg = args[i++];
             if (arg.equals("-jdkhome")) {
                 if (i < args.length) {
                     jdkhome = args[i++];
                 } else {
                     usage();
                 }
             } else if (arg.equals("-cpath")) {
                 if (i < args.length) {
                     cpath = args[i++];
                 } else {
                     usage();
                 }
             } else if (arg.equals("-config")) {
                 if (i < args.length) {
                     configs.add(args[i++]);
                 } else {
                     usage();
                 }
             } else if (arg.equals("-depconfig")) {
                 if (i < args.length) {
                     depconfigs.add(args[i++]);
                 } else {
                     usage();
                 }
             } else if (arg.equals("-output")) {
                 if (i < args.length) {
                     output = args[i++];
                 } else {
                     usage();
                 }
             } else if (arg.equals("-base")) {
                 ModuleConfig.setBaseModule(args[i++]);
             } else if (arg.equals("-nomerge")) {
                 // analyze the fine-grained module dependencies
                 mergeModules = false;
             } else if (arg.equals("-showdynamic")) {
                 showDynamic = true;
             } else {
                 System.err.println("Invalid option: " + arg);
                 usage();
             }
         }

         if ((jdkhome == null && cpath == null) || (jdkhome != null && cpath != null)) {
             usage();
         }
         if (configs.isEmpty()) {
             usage();
         }

         if (jdkhome != null) {
             ClassPath.setJDKHome(jdkhome);
         } else if (cpath != null) {
             ClassPath.setClassPath(cpath);
         }

         // create output directory if it doesn't exist
         File dir = new File(output);
         if (!dir.isDirectory()) {
             if (!dir.exists()) {
                 boolean created = dir.mkdir();
                 if (!created) {
                     throw new RuntimeException("Unable to create `" + dir + "'");
                 }
             }
         }

         buildModules(configs, depconfigs, mergeModules);

         // generate output files
         for (Module m : modules) {
             // only generate reports for top-level modules
             if (m.group() == m) {
                 m.printClassListTo(resolve(dir, m.name(), "classlist"));
                 m.printResourceListTo(resolve(dir, m.name(), "resources"));
                 m.printSummaryTo(resolve(dir, m.name(), "summary"));
                 m.printDependenciesTo(resolve(dir, m.name(), "dependencies"), showDynamic);
             }
         }

         // Generate other summary reports
         printModulesSummary(dir, showDynamic);
         printModulesDot(dir, showDynamic);
         printModulesList(dir);
         printPackagesSummary(dir);
     }
     private static List<Module> modules = new ArrayList<Module>();

     static void buildModules(List<String> configs,
             List<String> depconfigs,
             boolean mergeModules) throws IOException {
         // create modules based on the input config files
         for (String file : configs) {
             for (ModuleConfig mconfig : ModuleConfig.readConfigurationFile(file)) {
                 modules.add(Module.addModule(mconfig));
             }
         }

         // parse class files
         ClassPath.parseAllClassFiles();

         // Add additional dependencies if specified
         if (depconfigs != null && depconfigs.size() > 0) {
             DependencyConfig.parse(depconfigs);
         }

         // process the roots and dependencies to get the classes for each module
         for (Module m : modules) {
             m.processRootsAndReferences();
         }

         // update the dependencies for classes that were subsequently allocated
         // to modules
         for (Module m : modules) {
             m.fixupDependencies();
         }

         if (mergeModules) {
             Module.buildModuleMembers();
         }
     }

     private static void printModulesSummary(File dir, boolean showDynamic) throws IOException {
         // print summary of dependencies
         PrintWriter writer = new PrintWriter(new File(dir, "modules.summary"));
         try {
             for (Module m : modules) {
                 // only show top-level module dependencies
                 if (m.group() == m) {
                     for (Dependency dep : m.dependents()) {
                         if (!showDynamic && dep.dynamic && dep.optional) {
                             continue;
                         }
                         if (dep.module == null || !dep.module.isBase()) {

                             String prefix = "";
                             if (dep.optional) {
                                 if (dep.dynamic) {
                                     prefix = "[dynamic] ";
                                 } else {
                                     prefix = "[optional] ";
                                 }
                             }

                             Module other = dep != null ? dep.module : null;
                             writer.format("%s%s -> %s%n", prefix, m, other);
                         }
                     }
                 }
             }
         } finally {
             writer.close();
         }
     }

     private static void printModulesDot(File dir, boolean showDynamic) throws IOException {
         PrintWriter writer = new PrintWriter(new File(dir, "modules.dot"));
         try {
             writer.println("digraph jdk {");
             for (Module m : modules) {
                 if (m.group() == m) {
                     for (Dependency dep : m.dependents()) {
                         if (!showDynamic && dep.dynamic && dep.optional) {
                             continue;
                         }
                         if (dep.module == null || !dep.module.isBase()) {
                             String style = "";
                             String color = "";
                             String property = "";
                             if (dep.optional) {
                                 style = "style=dotted";
                             }
                             if (dep.dynamic) {
                                 color = "color=red";
                             }
                             if (style.length() > 0 || color.length() > 0) {
                                 String comma = "";
                                 if (style.length() > 0 && color.length() > 0) {
                                     comma = ", ";
                                 }
                                 property = String.format(" [%s%s%s]", style, comma, color);
                             }
                             Module other = dep != null ? dep.module : null;
                             writer.format("    \"%s\" -> \"%s\"%s;%n", m, other, property);
                         }
                     }
                 }
             }
             writer.println("}");
         } finally {
             writer.close();
         }
     }

     private static void printMembers(Module m, PrintWriter writer) {
         for (Module member : m.members()) {
             if (!member.isEmpty()) {
                 writer.format("%s ", member);
                 printMembers(member, writer);
             }
         }
     }

     private static void printModulesList(File dir) throws IOException {
         // print module group / members relationship
         PrintWriter writer = new PrintWriter(new File(dir, "modules.list"));
         try {
             for (Module m : modules) {
                 if (m.group() == m && !m.isEmpty()) {
                     writer.format("%s ", m);
                     printMembers(m, writer);
                     writer.println();
                 }
             }
         } finally {
             writer.close();
         }
     }

     private static void printPackagesSummary(File dir) throws IOException {
         // print package / module relationship
         PrintWriter writer = new PrintWriter(new File(dir, "modules.pkginfo"));
         try {
             Map<String, Set<Module>> packages = new TreeMap<String, Set<Module>>();
             Set<String> splitPackages = new TreeSet<String>();

             for (Module m : modules) {
                 if (m.group() == m) {
                     for (PackageInfo info : m.getPackageInfos()) {
                         Set<Module> value = packages.get(info.pkgName);
                         if (value == null) {
                             value = new TreeSet<Module>();
                             packages.put(info.pkgName, value);
                         } else {
                             // package in more than one module
                             splitPackages.add(info.pkgName);
                         }
                         value.add(m);
                     }
                 }
             }

             // packages that are splitted among multiple modules
             writer.println("Packages splitted across modules:-\n");
             writer.format("%-60s  %s\n", "Package", "Module");

             for (String pkgname : splitPackages) {
                 writer.format("%-60s", pkgname);
                 for (Module m : packages.get(pkgname)) {
                     writer.format("  %s", m);
                 }
                 writer.println();
             }

             writer.println("\nPackage-private dependencies:-");
             for (String pkgname : splitPackages) {
                 for (Klass k : Klass.getAllClasses()) {
                     if (k.getPackageName().equals(pkgname)) {
                         Module m = k.getModule();
                         // check if this klass references a package-private
                         // class that is in a different module
                         for (Klass other : k.getReferencedClasses()) {
                             if (other.getModule() != m &&
                                     !other.isPublic() &&
                                     other.getPackageName().equals(pkgname)) {
                                 String from = k.getClassName() + " (" + m + ")";
                                 writer.format("%-60s -> %s (%s)\n", from, other, other.getModule());
                             }
                         }
                     }
                 }
             }
         } finally {
             writer.close();
         }

     }

     private static String resolve(File dir, String mname, String suffix) {
         File f = new File(dir, mname + "." + suffix);
         return f.toString();

     }

     private static void usage() {
         System.out.println("Usage: ClassAnalyzer <options>");
         System.out.println("Options: ");
         System.out.println("\t-jdkhome <JDK home> where all jars will be parsed");
         System.out.println("\t-cpath   <classpath> where classes and jars will be parsed");
         System.out.println("\t         Either -jdkhome or -cpath option can be used.");
         System.out.println("\t-config  <module config file>");
         System.out.println("\t         This option can be repeated for multiple module config files");
         System.out.println("\t-output  <output dir>");
         System.out.println("\t-nomerge specify not to merge modules");
         System.out.println("\t-showdynamic show dynamic dependencies in the reports");
         System.exit(-1);
     }
 }
	/*
	* Copyright (c) 2009, 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.
	*
	* 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 com.sun.classanalyzer;

	import com.sun.classanalyzer.AnnotatedDependency.*;
	import com.sun.classanalyzer.Module.Dependency;
	import com.sun.classanalyzer.Module.PackageInfo;
	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.List;
	import java.io.File;
	import java.io.PrintWriter;
	import java.util.Map;
	import java.util.Set;
	import java.util.TreeMap;
	import java.util.TreeSet;

	/**
	*
	* @author Mandy Chung
	*/
	public class ClassAnalyzer {

	public static void main(String[] args) throws Exception {
	String jdkhome = null;
	String cpath = null;
	List<String> configs = new ArrayList<String>();
	List<String> depconfigs = new ArrayList<String>();
	String output = ".";
	boolean mergeModules = true;
	boolean showDynamic = false;

	// process arguments
	int i = 0;
	while (i < args.length) {
	String arg = args[i++];
	if (arg.equals("-jdkhome")) {
	if (i < args.length) {
	jdkhome = args[i++];
	} else {
	usage();
	}
	} else if (arg.equals("-cpath")) {
	if (i < args.length) {
	cpath = args[i++];
	} else {
	usage();
	}
	} else if (arg.equals("-config")) {
	if (i < args.length) {
	configs.add(args[i++]);
	} else {
	usage();
	}
	} else if (arg.equals("-depconfig")) {
	if (i < args.length) {
	depconfigs.add(args[i++]);
	} else {
	usage();
	}
	} else if (arg.equals("-output")) {
	if (i < args.length) {
	output = args[i++];
	} else {
	usage();
	}
	} else if (arg.equals("-base")) {
	ModuleConfig.setBaseModule(args[i++]);
	} else if (arg.equals("-nomerge")) {
	// analyze the fine-grained module dependencies
	mergeModules = false;
	} else if (arg.equals("-showdynamic")) {
	showDynamic = true;
	} else {
	System.err.println("Invalid option: " + arg);
	usage();
	}
	}

	if ((jdkhome == null && cpath == null) \|\| (jdkhome != null && cpath != null)) {
	usage();
	}
	if (configs.isEmpty()) {
	usage();
	}

	if (jdkhome != null) {
	ClassPath.setJDKHome(jdkhome);
	} else if (cpath != null) {
	ClassPath.setClassPath(cpath);
	}

	// create output directory if it doesn't exist
	File dir = new File(output);
	if (!dir.isDirectory()) {
	if (!dir.exists()) {
	boolean created = dir.mkdir();
	if (!created) {
	throw new RuntimeException("Unable to create `" + dir + "'");
	}
	}
	}

	buildModules(configs, depconfigs, mergeModules);

	// generate output files
	for (Module m : modules) {
	// only generate reports for top-level modules
	if (m.group() == m) {
	m.printClassListTo(resolve(dir, m.name(), "classlist"));
	m.printResourceListTo(resolve(dir, m.name(), "resources"));
	m.printSummaryTo(resolve(dir, m.name(), "summary"));
	m.printDependenciesTo(resolve(dir, m.name(), "dependencies"), showDynamic);
	}
	}

	// Generate other summary reports
	printModulesSummary(dir, showDynamic);
	printModulesDot(dir, showDynamic);
	printModulesList(dir);
	printPackagesSummary(dir);
	}
	private static List<Module> modules = new ArrayList<Module>();

	static void buildModules(List<String> configs,
	List<String> depconfigs,
	boolean mergeModules) throws IOException {
	// create modules based on the input config files
	for (String file : configs) {
	for (ModuleConfig mconfig : ModuleConfig.readConfigurationFile(file)) {
	modules.add(Module.addModule(mconfig));
	}
	}

	// parse class files
	ClassPath.parseAllClassFiles();

	// Add additional dependencies if specified
	if (depconfigs != null && depconfigs.size() > 0) {
	DependencyConfig.parse(depconfigs);
	}

	// process the roots and dependencies to get the classes for each module
	for (Module m : modules) {
	m.processRootsAndReferences();
	}

	// update the dependencies for classes that were subsequently allocated
	// to modules
	for (Module m : modules) {
	m.fixupDependencies();
	}

	if (mergeModules) {
	Module.buildModuleMembers();
	}
	}

	private static void printModulesSummary(File dir, boolean showDynamic) throws IOException {
	// print summary of dependencies
	PrintWriter writer = new PrintWriter(new File(dir, "modules.summary"));
	try {
	for (Module m : modules) {
	// only show top-level module dependencies
	if (m.group() == m) {
	for (Dependency dep : m.dependents()) {
	if (!showDynamic && dep.dynamic && dep.optional) {
	continue;
	}
	if (dep.module == null \|\| !dep.module.isBase()) {

	String prefix = "";
	if (dep.optional) {
	if (dep.dynamic) {
	prefix = "[dynamic] ";
	} else {
	prefix = "[optional] ";
	}
	}

	Module other = dep != null ? dep.module : null;
	writer.format("%s%s -> %s%n", prefix, m, other);
	}
	}
	}
	}
	} finally {
	writer.close();
	}
	}

	private static void printModulesDot(File dir, boolean showDynamic) throws IOException {
	PrintWriter writer = new PrintWriter(new File(dir, "modules.dot"));
	try {
	writer.println("digraph jdk {");
	for (Module m : modules) {
	if (m.group() == m) {
	for (Dependency dep : m.dependents()) {
	if (!showDynamic && dep.dynamic && dep.optional) {
	continue;
	}
	if (dep.module == null \|\| !dep.module.isBase()) {
	String style = "";
	String color = "";
	String property = "";
	if (dep.optional) {
	style = "style=dotted";
	}
	if (dep.dynamic) {
	color = "color=red";
	}
	if (style.length() > 0 \|\| color.length() > 0) {
	String comma = "";
	if (style.length() > 0 && color.length() > 0) {
	comma = ", ";
	}
	property = String.format(" [%s%s%s]", style, comma, color);
	}
	Module other = dep != null ? dep.module : null;
	writer.format(" \"%s\" -> \"%s\"%s;%n", m, other, property);
	}
	}
	}
	}
	writer.println("}");
	} finally {
	writer.close();
	}
	}

	private static void printMembers(Module m, PrintWriter writer) {
	for (Module member : m.members()) {
	if (!member.isEmpty()) {
	writer.format("%s ", member);
	printMembers(member, writer);
	}
	}
	}

	private static void printModulesList(File dir) throws IOException {
	// print module group / members relationship
	PrintWriter writer = new PrintWriter(new File(dir, "modules.list"));
	try {
	for (Module m : modules) {
	if (m.group() == m && !m.isEmpty()) {
	writer.format("%s ", m);
	printMembers(m, writer);
	writer.println();
	}
	}
	} finally {
	writer.close();
	}
	}

	private static void printPackagesSummary(File dir) throws IOException {
	// print package / module relationship
	PrintWriter writer = new PrintWriter(new File(dir, "modules.pkginfo"));
	try {
	Map<String, Set<Module>> packages = new TreeMap<String, Set<Module>>();
	Set<String> splitPackages = new TreeSet<String>();

	for (Module m : modules) {
	if (m.group() == m) {
	for (PackageInfo info : m.getPackageInfos()) {
	Set<Module> value = packages.get(info.pkgName);
	if (value == null) {
	value = new TreeSet<Module>();
	packages.put(info.pkgName, value);
	} else {
	// package in more than one module
	splitPackages.add(info.pkgName);
	}
	value.add(m);
	}
	}
	}

	// packages that are splitted among multiple modules
	writer.println("Packages splitted across modules:-\n");
	writer.format("%-60s %s\n", "Package", "Module");

	for (String pkgname : splitPackages) {
	writer.format("%-60s", pkgname);
	for (Module m : packages.get(pkgname)) {
	writer.format(" %s", m);
	}
	writer.println();
	}

	writer.println("\nPackage-private dependencies:-");
	for (String pkgname : splitPackages) {
	for (Klass k : Klass.getAllClasses()) {
	if (k.getPackageName().equals(pkgname)) {
	Module m = k.getModule();
	// check if this klass references a package-private
	// class that is in a different module
	for (Klass other : k.getReferencedClasses()) {
	if (other.getModule() != m &&
	!other.isPublic() &&
	other.getPackageName().equals(pkgname)) {
	String from = k.getClassName() + " (" + m + ")";
	writer.format("%-60s -> %s (%s)\n", from, other, other.getModule());
	}
	}
	}
	}
	}
	} finally {
	writer.close();
	}

	}

	private static String resolve(File dir, String mname, String suffix) {
	File f = new File(dir, mname + "." + suffix);
	return f.toString();

	}

	private static void usage() {
	System.out.println("Usage: ClassAnalyzer <options>");
	System.out.println("Options: ");
	System.out.println("\t-jdkhome <JDK home> where all jars will be parsed");
	System.out.println("\t-cpath <classpath> where classes and jars will be parsed");
	System.out.println("\t Either -jdkhome or -cpath option can be used.");
	System.out.println("\t-config <module config file>");
	System.out.println("\t This option can be repeated for multiple module config files");
	System.out.println("\t-output <output dir>");
	System.out.println("\t-nomerge specify not to merge modules");
	System.out.println("\t-showdynamic show dynamic dependencies in the reports");
	System.exit(-1);
	}
	}