1 /*

     2  * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  *

    23  */

    24 package com.sun.classanalyzer;

    25 

    26 import com.sun.classanalyzer.AnnotatedDependency.OptionalDependency;

    27 import java.io.IOException;

    28 import java.io.PrintWriter;

    29 import java.util.ArrayDeque;

    30 import java.util.Collection;

    31 import java.util.Collections;

    32 import java.util.Deque;

    33 import java.util.HashSet;

    34 import java.util.LinkedHashMap;

    35 import java.util.Map;

    36 import java.util.Set;

    37 import java.util.TreeMap;

    38 import java.util.TreeSet;

    39 

    40 /**

    41  *

    42  * @author Mandy Chung

    43  */

    44 public class Module implements Comparable<Module> {

    45 

    46     private static Map<String, Module> modules = new LinkedHashMap<String, Module>();

    47 

    48     public static Module addModule(ModuleConfig config) {

    49         String name = config.module;

    50         if (modules.containsKey(name)) {

    51             throw new RuntimeException("module \"" + name + "\" already exists");

    52         }

    53 

    54         Module m = new Module(config);

    55         modules.put(name, m);

    56         return m;

    57     }

    58 

    59     public static Module findModule(String name) {

    60         return modules.get(name);

    61     }

    62 

    63     static Collection<Module> getAllModules() {

    64         return Collections.unmodifiableCollection(modules.values());

    65     }

    66     private final String name;

    67     private final ModuleConfig config;

    68     private final Set<Klass> classes;

    69     private final Set<ResourceFile> resources;

    70     private final Set<Reference> unresolved;

    71     private final Set<Dependency> dependents;

    72     private final Map<String, PackageInfo> packages;

    73     private final Set<Module> members;

    74     private Module group;

    75     private boolean isBaseModule;

    76 

    77     private Module(ModuleConfig config) {

    78         this.name = config.module;

    79         this.isBaseModule = config.isBase;

    80         this.classes = new TreeSet<Klass>();

    81         this.resources = new TreeSet<ResourceFile>();

    82         this.config = config;

    83         this.unresolved = new HashSet<Reference>();

    84         this.dependents = new TreeSet<Dependency>();

    85         this.packages = new TreeMap<String, PackageInfo>();

    86         this.members = new TreeSet<Module>();

    87         this.group = this; // initialize to itself

    88     }

    89 

    90     String name() {

    91         return name;

    92     }

    93 

    94     Module group() {

    95         return group;

    96     }

    97 

    98     boolean isBase() {

    99         return isBaseModule;

   100     }

   101 

   102     Set<Module> members() {

   103         return members;

   104     }

   105 

   106     boolean contains(Klass k) {

   107         return k != null && classes.contains(k);

   108     }

   109 

   110     boolean isEmpty() {

   111         return classes.isEmpty() && resources.isEmpty();

   112     }

   113 

   114     /**

   115      * Returns an Iterable of Dependency, only one for each dependent

   116      * module of the strongest dependency (i.e.

   117      * hard static > hard dynamic > optional static > optional dynamic

   118      */

   119     Iterable<Dependency> dependents() {

   120         Map<Module, Dependency> deps = new LinkedHashMap<Module, Dependency>();

   121         for (Dependency dep : dependents) {

   122             Dependency d = deps.get(dep.module);

   123             if (d == null || dep.compareTo(d) > 0) {

   124                 deps.put(dep.module, dep);

   125             }

   126         }

   127         return deps.values();

   128     }

   129 

   130     @Override

   131     public int compareTo(Module o) {

   132         if (o == null) {

   133             return -1;

   134         }

   135         return name.compareTo(o.name);

   136     }

   137 

   138     @Override

   139     public String toString() {

   140         return name;

   141     }

   142 

   143     void addKlass(Klass k) {

   144         classes.add(k);

   145         k.setModule(this);

   146 

   147         // update package statistics

   148         String pkg = k.getPackageName();

   149         PackageInfo pkginfo = packages.get(pkg);

   150         if (pkginfo == null) {

   151             pkginfo = new PackageInfo(pkg);

   152             packages.put(pkg, pkginfo);

   153         }

   154         if (k.exists()) {

   155             // only count the class that is parsed

   156             pkginfo.add(k.getFileSize());

   157         }

   158     }

   159 

   160     void addResource(ResourceFile res) {

   161         resources.add(res);

   162         res.setModule(this);

   163     }

   164 

   165     void processRootsAndReferences() {

   166         // start with the root set

   167         Deque<Klass> pending = new ArrayDeque<Klass>();

   168         for (Klass k : Klass.getAllClasses()) {

   169             if (k.getModule() != null) {

   170                 continue;

   171             }

   172             String classname = k.getClassName();

   173             if (config.matchesRoot(classname) && !config.isExcluded(classname)) {

   174                 addKlass(k);

   175                 pending.add(k);

   176             }

   177         }

   178 

   179         // follow all references

   180         Klass k;

   181         while ((k = pending.poll()) != null) {

   182             if (!classes.contains(k)) {

   183                 addKlass(k);

   184             }

   185             for (Klass other : k.getReferencedClasses()) {

   186                 Module otherModule = other.getModule();

   187                 if (otherModule != null && otherModule != this) {

   188                     // this module is dependent on otherModule

   189                     addDependency(k, other);

   190                     continue;

   191                 }

   192 

   193                 if (!classes.contains(other)) {

   194                     if (config.isExcluded(other.getClassName())) {

   195                         // reference to an excluded class

   196                         unresolved.add(new Reference(k, other));

   197                     } else {

   198                         pending.add(other);

   199                     }

   200                 }

   201             }

   202         }

   203 

   204         // add other matching classes that don't require dependency analysis

   205         for (Klass c : Klass.getAllClasses()) {

   206             if (c.getModule() == null) {

   207                 String classname = c.getClassName();

   208                 if (config.matchesIncludes(classname) && !config.isExcluded(classname)) {

   209                     addKlass(c);

   210                     // dependencies

   211                     for (Klass other : c.getReferencedClasses()) {

   212                         Module otherModule = other.getModule();

   213                         if (otherModule == null) {

   214                             unresolved.add(new Reference(c, other));

   215                         } else {

   216                             if (otherModule != this) {

   217                                 // this module is dependent on otherModule

   218                                 addDependency(c, other);

   219                             }

   220                         }

   221                     }

   222                 }

   223             }

   224         }

   225 

   226 

   227         // add other matching classes that don't require dependency analysis

   228         for (ResourceFile res : ResourceFile.getAllResources()) {

   229             if (res.getModule() == null) {

   230                 String name = res.getName();

   231                 if (config.matchesIncludes(name) && !config.isExcluded(name)) {

   232                     addResource(res);

   233                 }

   234             }

   235         }

   236     }

   237 

   238     void addDependency(Klass from, Klass to) {

   239         Dependency dep = new Dependency(from, to);

   240         dependents.add(dep);

   241     }

   242 

   243     void fixupDependencies() {

   244         // update dependencies for classes that were allocated to modules after

   245         // this module was processed.

   246         for (Reference ref : unresolved) {

   247             Module m = ref.referree().getModule();

   248             if (m == null || m != this) {

   249                 addDependency(ref.referrer, ref.referree);

   250             }

   251         }

   252 

   253         fixupAnnotatedDependencies();

   254     }

   255 

   256     private void fixupAnnotatedDependencies() {

   257         // add dependencies that this klass may depend on due to the AnnotatedDependency

   258         dependents.addAll(AnnotatedDependency.getDependencies(this));

   259     }

   260 

   261     boolean isModuleDependence(Klass k) {

   262         Module m = k.getModule();

   263         return m == null || (!classes.contains(k) && !m.isBase());

   264     }

   265 

   266     Module getModuleDependence(Klass k) {

   267         if (isModuleDependence(k)) {

   268             Module m = k.getModule();

   269             if (group == this && m != null) {

   270                 // top-level module

   271                 return m.group;

   272             } else {

   273                 return m;

   274             }

   275         }

   276         return null;

   277     }

   278 

   279     <P> void visit(Set<Module> visited, Visitor<P> visitor, P p) {

   280         if (!visited.contains(this)) {

   281             visited.add(this);

   282             visitor.preVisit(this, p);

   283             for (Module m : members) {

   284                 m.visit(visited, visitor, p);

   285                 visitor.postVisit(this, m, p);

   286             }

   287         } else {

   288             throw new RuntimeException("Cycle detected: module " + this.name);

   289         }

   290     }

   291 

   292     void addMember(Module m) {

   293         // merge class list

   294         for (Klass k : m.classes) {

   295             classes.add(k);

   296         }

   297 

   298         // merge resource list

   299         for (ResourceFile res : m.resources) {

   300             resources.add(res);

   301         }

   302 

   303         // merge the package statistics

   304         for (PackageInfo pinfo : m.getPackageInfos()) {

   305             String packageName = pinfo.pkgName;

   306             PackageInfo pkginfo = packages.get(packageName);

   307             if (pkginfo == null) {

   308                 pkginfo = new PackageInfo(packageName);

   309                 packages.put(packageName, pkginfo);

   310             }

   311             pkginfo.add(pinfo);

   312         }

   313     }

   314 

   315     static void buildModuleMembers() {

   316         // set up module member relationship

   317         for (Module m : modules.values()) {

   318             m.group = m; // initialize to itself

   319             for (String name : m.config.members()) {

   320                 Module member = modules.get(name);

   321                 if (member == null) {

   322                     throw new RuntimeException("module \"" + name + "\" doesn't exist");

   323                 }

   324                 m.members.add(member);

   325             }

   326         }

   327 

   328         // set up the top-level module

   329         Visitor<Module> groupSetter = new Visitor<Module>() {

   330 

   331             public void preVisit(Module m, Module p) {

   332                 m.group = p;

   333                 if (p.isBaseModule) {

   334                     // all members are also base

   335                     m.isBaseModule = true;

   336                 }

   337             }

   338 

   339             public void postVisit(Module m, Module child, Module p) {

   340                 // nop - breadth-first search

   341             }

   342         };

   343 

   344         // propagate the top-level module to all its members

   345         for (Module p : modules.values()) {

   346             for (Module m : p.members) {

   347                 if (m.group == m) {

   348                     m.visit(new TreeSet<Module>(), groupSetter, p);

   349                 }

   350             }

   351         }

   352 

   353         Visitor<Module> mergeClassList = new Visitor<Module>() {

   354 

   355             public void preVisit(Module m, Module p) {

   356                 // nop - depth-first search

   357             }

   358 

   359             public void postVisit(Module m, Module child, Module p) {

   360                 m.addMember(child);

   361             }

   362         };

   363 

   364         Set<Module> visited = new TreeSet<Module>();

   365         for (Module m : modules.values()) {

   366             if (m.group() == m) {

   367                 if (m.members().size() > 0) {

   368                     // merge class list from all its members

   369                     m.visit(visited, mergeClassList, m);

   370                 }

   371 

   372                 // clear the dependencies before fixup

   373                 m.dependents.clear();

   374 

   375                 // fixup dependencies

   376                 for (Klass k : m.classes) {

   377                     for (Klass other : k.getReferencedClasses()) {

   378                         if (m.isModuleDependence(other)) {

   379                             // this module is dependent on otherModule

   380                             m.addDependency(k, other);

   381                         }

   382                     }

   383                 }

   384 

   385                 // add dependencies that this klass may depend on due to the AnnotatedDependency

   386                 m.fixupAnnotatedDependencies();

   387             }

   388         }

   389     }

   390 

   391     class PackageInfo implements Comparable {

   392 

   393         final String pkgName;

   394         int count;

   395         long filesize;

   396 

   397         PackageInfo(String name) {

   398             this.pkgName = name;

   399             this.count = 0;

   400             this.filesize = 0;

   401         }

   402 

   403         void add(PackageInfo pkg) {

   404             this.count += pkg.count;

   405             this.filesize += pkg.filesize;

   406         }

   407 

   408         void add(long size) {

   409             count++;

   410             filesize += size;

   411 

   412         }

   413 

   414         @Override

   415         public int compareTo(Object o) {

   416             return pkgName.compareTo(((PackageInfo) o).pkgName);

   417         }

   418     }

   419 

   420     Set<PackageInfo> getPackageInfos() {

   421         return new TreeSet<PackageInfo>(packages.values());

   422     }

   423 

   424     void printSummaryTo(String output) throws IOException {

   425         PrintWriter writer = new PrintWriter(output);

   426         try {

   427             long total = 0L;

   428             int count = 0;

   429             writer.format("%10s\t%10s\t%s\n", "Bytes", "Classes", "Package name");

   430             for (String pkg : packages.keySet()) {

   431                 PackageInfo info = packages.get(pkg);

   432                 if (info.count > 0) {

   433                     writer.format("%10d\t%10d\t%s\n", info.filesize, info.count, pkg);

   434                     total += info.filesize;

   435                     count += info.count;

   436                 }

   437             }

   438 

   439             writer.format("\nTotal: %d bytes (uncompressed) %d classes\n", total, count);

   440         } finally {

   441             writer.close();

   442         }

   443 

   444     }

   445 

   446     void printClassListTo(String output) throws IOException {

   447         // no file created if the module doesn't have any class nor resource

   448         if (isEmpty()) {

   449             return;

   450         }

   451 

   452         PrintWriter writer = new PrintWriter(output);

   453         try {

   454             for (Klass c : classes) {

   455                 if (c.exists()) {

   456                     writer.format("%s\n", c.getClassFilePathname());

   457                 } else {

   458                     trace("%s in module %s missing\n", c, this);

   459                 }

   460             }

   461 

   462         } finally {

   463             writer.close();

   464         }

   465     }

   466 

   467     void printResourceListTo(String output) throws IOException {

   468         // no file created if the module doesn't have any resource file

   469         if (resources.isEmpty()) {

   470             return;

   471         }

   472 

   473         PrintWriter writer = new PrintWriter(output);

   474         try {

   475             for (ResourceFile res : resources) {

   476                 writer.format("%s\n", res.getPathname());

   477             }

   478         } finally {

   479             writer.close();

   480         }

   481     }

   482 

   483     void printDependenciesTo(String output, boolean showDynamic) throws IOException {

   484         // no file created if the module doesn't have any class

   485         if (isEmpty()) {

   486             return;

   487         }

   488 

   489         PrintWriter writer = new PrintWriter(output);

   490         try {

   491             // classes that this klass may depend on due to the AnnotatedDependency

   492             Map<Reference, Set<AnnotatedDependency>> annotatedDeps = AnnotatedDependency.getReferences(this);

   493 

   494             for (Klass klass : classes) {

   495                 Set<Klass> references = klass.getReferencedClasses();

   496                 for (Klass other : references) {

   497                     String classname = klass.getClassName();

   498                     boolean optional = OptionalDependency.isOptional(klass, other);

   499                     if (optional) {

   500                         classname = "[optional] " + classname;

   501                     }

   502 

   503                     Module m = getModuleDependence(other);

   504                     if (m != null || other.getModule() == null) {

   505                         writer.format("%-40s -> %s (%s)", classname, other, m);

   506                         Reference ref = new Reference(klass, other);

   507                         if (annotatedDeps.containsKey(ref)) {

   508                             for (AnnotatedDependency ad : annotatedDeps.get(ref)) {

   509                                 writer.format(" %s", ad.getTag());

   510                             }

   511                             // printed; so remove the dependency from the annotated deps list

   512                             annotatedDeps.remove(ref);

   513                         }

   514                         writer.format("\n");

   515                     }

   516                 }

   517             }

   518 

   519 

   520             // print remaining dependencies specified in AnnotatedDependency list

   521             if (annotatedDeps.size() > 0) {

   522                 for (Map.Entry<Reference, Set<AnnotatedDependency>> entry : annotatedDeps.entrySet()) {

   523                     Reference ref = entry.getKey();

   524                     Module m = getModuleDependence(ref.referree);

   525                     if (m != null || ref.referree.getModule() == null) {

   526                         String classname = ref.referrer.getClassName();

   527                         boolean optional = true;

   528                         boolean dynamic = true;

   529                         String tag = "";

   530                         for (AnnotatedDependency ad : entry.getValue()) {

   531                             if (optional && !ad.isOptional()) {

   532                                 optional = false;

   533                                 tag = ad.getTag();

   534                             }

   535                             if (!ad.isDynamic()) {

   536                                 dynamic = false;

   537                             }

   538                         }

   539                         if (!showDynamic && optional && dynamic) {

   540                             continue;

   541                         }

   542                         if (optional) {

   543                             if (dynamic) {

   544                                 classname = "[dynamic] " + classname;

   545                             } else {

   546                                 classname = "[optional] " + classname;

   547                             }

   548                         }

   549                         writer.format("%-40s -> %s (%s) %s%n", classname, ref.referree, m, tag);

   550                     }

   551                 }

   552             }

   553 

   554         } finally {

   555             writer.close();

   556         }

   557     }

   558 

   559     static class Dependency implements Comparable<Dependency> {

   560 

   561         final Module module;

   562         final boolean optional;

   563         final boolean dynamic;

   564 

   565         Dependency(Klass from, Klass to) {

   566             // static dependency

   567             this.module = to.getModule() != null ? to.getModule().group() : null;

   568             this.optional = OptionalDependency.isOptional(from, to);

   569             this.dynamic = false;

   570         }

   571 

   572         Dependency(Module m, boolean optional, boolean dynamic) {

   573             this.module = m != null ? m.group() : null;

   574             this.optional = optional;

   575             this.dynamic = dynamic;

   576         }

   577 

   578         @Override

   579         public boolean equals(Object obj) {

   580             if (!(obj instanceof Dependency)) {

   581                 return false;

   582             }

   583             if (this == obj) {

   584                 return true;

   585             }

   586 

   587             Dependency d = (Dependency) obj;

   588             if (this.module != d.module) {

   589                 return false;

   590             } else {

   591                 return this.optional == d.optional && this.dynamic == d.dynamic;

   592             }

   593         }

   594 

   595         @Override

   596         public int hashCode() {

   597             int hash = 3;

   598             hash = 19 * hash + (this.module != null ? this.module.hashCode() : 0);

   599             hash = 19 * hash + (this.optional ? 1 : 0);

   600             hash = 19 * hash + (this.dynamic ? 1 : 0);

   601             return hash;

   602         }

   603 

   604         @Override

   605         public int compareTo(Dependency d) {

   606             if (this.equals(d)) {

   607                 return 0;

   608             }

   609 

   610             // Hard static > hard dynamic > optional static > optional dynamic

   611             if (this.module == d.module) {

   612                 if (this.optional == d.optional) {

   613                     return this.dynamic ? -1 : 1;

   614                 } else {

   615                     return this.optional ? -1 : 1;

   616                 }

   617             } else if (this.module != null && d.module != null) {

   618                 return (this.module.compareTo(d.module));

   619             } else {

   620                 return (this.module == null) ? -1 : 1;

   621             }

   622         }

   623 

   624         @Override

   625         public String toString() {

   626             String s = module.name();

   627             if (dynamic && optional) {

   628                 s += " (dynamic)";

   629             } else if (optional) {

   630                 s += " (optional)";

   631             }

   632             return s;

   633         }

   634     }

   635 

   636     static class Reference implements Comparable<Reference> {

   637 

   638         private final Klass referrer, referree;

   639 

   640         Reference(Klass referrer, Klass referree) {

   641             this.referrer = referrer;

   642             this.referree = referree;

   643         }

   644 

   645         Klass referrer() {

   646             return referrer;

   647         }

   648 

   649         Klass referree() {

   650             return referree;

   651         }

   652 

   653         @Override

   654         public int hashCode() {

   655             return referrer.hashCode() ^ referree.hashCode();

   656         }

   657 

   658         @Override

   659         public boolean equals(Object obj) {

   660             if (!(obj instanceof Reference)) {

   661                 return false;

   662             }

   663             if (this == obj) {

   664                 return true;

   665             }

   666 

   667             Reference r = (Reference) obj;

   668             return (this.referrer.equals(r.referrer) &&

   669                     this.referree.equals(r.referree));

   670         }

   671 

   672         @Override

   673         public int compareTo(Reference r) {

   674             int ret = referrer.compareTo(r.referrer);

   675             if (ret == 0) {

   676                 ret = referree.compareTo(r.referree);

   677             }

   678             return ret;

   679         }

   680     }

   681 

   682     interface Visitor<P> {

   683 

   684         public void preVisit(Module m, P param);

   685 

   686         public void postVisit(Module m, Module child, P param);

   687     }

   688     private static boolean traceOn = System.getProperty("classanalyzer.debug") != null;

   689 

   690     private static void trace(String format, Object... params) {

   691         System.err.format(format, params);

   692     }

   693 }