dev/core/src/com/google/gwt/soyc/SoycDashboard.java - gwt - Git at Google

 /*
  * Copyright 2008 Google Inc.
  *
  * 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.google.gwt.soyc;

 import com.google.gwt.core.ext.linker.CompilationMetricsArtifact;
 import com.google.gwt.core.ext.linker.ModuleMetricsArtifact;
 import com.google.gwt.core.ext.linker.PrecompilationMetricsArtifact;
 import com.google.gwt.dev.util.StringInterner;
 import com.google.gwt.soyc.MakeTopLevelHtmlForPerm.DependencyLinker;
 import com.google.gwt.soyc.MakeTopLevelHtmlForPerm.NullDependencyLinker;
 import com.google.gwt.soyc.io.OutputDirectory;

 import org.xml.sax.Attributes;
 import org.xml.sax.SAXException;
 import org.xml.sax.helpers.DefaultHandler;

 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.TreeMap;
 import java.util.TreeSet;

 import javax.xml.parsers.ParserConfigurationException;
 import javax.xml.parsers.SAXParser;
 import javax.xml.parsers.SAXParserFactory;

 /**
  * The command-line entry point for creating a compile report.
  */
 public class SoycDashboard {
   private static class FormatException extends RuntimeException {
     public FormatException() {
       super();
     }

     public FormatException(String message) {
       super(message);
     }

     public FormatException(Throwable cause) {
       super(cause);
     }
   }

   /*
    * cleans up the RPC code categories
    */
   private static void foldInRPCHeuristic(
       final HashMap<String, CodeCollection> nameToCodeColl) {
     /**
      * Heuristic: this moves all classes that override serializable from RPC to
      * "Other Code" *if* there is no RPC generated code, i.e., if the
      * application really is not using RPC
      */

     if (nameToCodeColl.get("rpcGen").classes.size() == 0) {

       for (String className : nameToCodeColl.get("rpcUser").classes) {

         if ((!nameToCodeColl.get("widget").classes.contains(className))
             && (!nameToCodeColl.get("jre").classes.contains(className))
             && (!nameToCodeColl.get("gwtLang").classes.contains(className))) {
           nameToCodeColl.get("allOther").classes.add(className);
         }
       }
       nameToCodeColl.get("rpcUser").classes.clear();

       for (String className : nameToCodeColl.get("rpcGwt").classes) {
         if ((!nameToCodeColl.get("widget").classes.contains(className))
             && (!nameToCodeColl.get("jre").classes.contains(className))
             && (!nameToCodeColl.get("gwtLang").classes.contains(className))) {
           nameToCodeColl.get("allOther").classes.add(className);
         }
       }
       nameToCodeColl.get("rpcGwt").classes.clear();
     }
   }

   private static DefaultHandler parseXMLDocumentDependencies(
       final Map<String, Map<String, String>> allDependencies) {
     DefaultHandler handler = new DefaultHandler() {

       // may want to create a class for this later
       String curMethod;
       Map<String, String> dependencies = new TreeMap<String, String>();
       String graphExtends = null;
       StringBuilder valueBuilder = new StringBuilder();

       @Override
       public void endElement(String uri, String localName, String qName) {
         if (localName.compareTo("table") == 0) {
           if (graphExtends != null) {
             // Add in elements from the extended graph
             for (Entry<String, String> entry : allDependencies.get(graphExtends).entrySet()) {
               dependencies.put(entry.getKey(), entry.getValue());
             }
           }
         }
       }

       @Override
       public void startElement(String nsUri, String strippedName,
           String tagName, final Attributes attributes) {

         valueBuilder.delete(0, valueBuilder.length());

         if (strippedName.compareTo("table") == 0
             && (attributes.getValue("name") != null)) {
           String name = attributes.getValue("name");
           dependencies = new TreeMap<String, String>();
           allDependencies.put(StringInterner.get().intern(name), dependencies);
           if (attributes.getValue("extends") != null) {
             graphExtends = StringInterner.get().intern(attributes.getValue("extends"));
             if (!allDependencies.containsKey(graphExtends)) {
               throw new FormatException("Graph " + name
                   + " extends an unknown graph " + graphExtends);
             }
           } else {
             graphExtends = null;
           }
         } else if ((strippedName.compareTo("method") == 0)
             && (attributes.getValue("name") != null)) {
           curMethod = StringInterner.get().intern(attributes.getValue("name"));
         } else if ((strippedName.compareTo("called") == 0)
             && (attributes.getValue("by") != null)) {
           String curDepMethod = attributes.getValue("by");
           if (!dependencies.containsKey(curMethod)) {
             dependencies.put(StringInterner.get().intern(curMethod),
                 StringInterner.get().intern(curDepMethod));
           }
         }
       }
     };
     return handler;
   }

   /**
    * Global information for the current permutation being emitted.
    */
   private GlobalInformation globalInformation;

   /**
    * HTML emitter for the current permutation being emitted.
    */
   private MakeTopLevelHtmlForPerm makeTopLevelHtmlForPerm;

   private final OutputDirectory outDir;

   public SoycDashboard(OutputDirectory outDir) {
     this.outDir = outDir;
   }

   public void generateCompilerMetricsForOnePermutation(
       ModuleMetricsArtifact moduleMetrics,
       PrecompilationMetricsArtifact precompilationMetrics,
       CompilationMetricsArtifact compilationMetrics)  throws IOException {
     makeTopLevelHtmlForPerm.makeCompilerMetricsPermFiles(moduleMetrics,
         precompilationMetrics, compilationMetrics);
   }

   public void generateCrossPermutationFiles(Map<String, List<String>> permInfo)
       throws IOException {
     StaticResources.emit(outDir);
     MakeTopLevelHtmlForPerm.makeTopLevelHtmlForAllPerms(permInfo, outDir);
   }

   public void generateForOnePermutation() throws IOException {
     if (globalInformation.dependencies != null) {
       makeTopLevelHtmlForPerm.makeDependenciesHtml();
     }

     if (globalInformation.getNumFragments() > 0) {
       makeTopLevelHtmlForPerm.makeSplitStatusPages();
       makeTopLevelHtmlForPerm.makeLeftoverStatusPages();
     }
     for (SizeBreakdown breakdown : globalInformation.allSizeBreakdowns()) {
       DependencyLinker linker = chooseDependencyLinker(breakdown);
       makeHTMLFiles(makeTopLevelHtmlForPerm, breakdown, linker);
     }
   }

   public void readDependencies(InputStream stream)
       throws ParserConfigurationException, SAXException, IOException {
     globalInformation.dependencies = new TreeMap<String, Map<String, String>>();
     DefaultHandler depHandler = parseXMLDocumentDependencies(globalInformation.dependencies);
     SAXParserFactory depFactoryMain = SAXParserFactory.newInstance();
     depFactoryMain.setNamespaceAware(true);
     SAXParser saxParser = depFactoryMain.newSAXParser();
     saxParser.parse(stream, depHandler);
   }

   public void readSizeMaps(InputStream stream)
       throws ParserConfigurationException, SAXException, IOException {
     DefaultHandler handler = parseXMLDocumentSizeMap(globalInformation);
     SAXParserFactory factoryMain = SAXParserFactory.newInstance();
     factoryMain.setNamespaceAware(true);
     SAXParser saxParser = factoryMain.newSAXParser();
     saxParser.parse(stream, handler);

     // Now clean up the information that has been read in various ways
     globalInformation.computePackageSizes();

     // add to "All Other Code" if none of the special categories apply
     for (SizeBreakdown breakdown : globalInformation.allSizeBreakdowns()) {
       updateAllOtherCodeType(breakdown.nameToCodeColl);
     }

     // clean up the RPC categories
     for (SizeBreakdown breakdown : globalInformation.allSizeBreakdowns()) {
       foldInRPCHeuristic(breakdown.nameToCodeColl);
     }
   }

   public void readSplitPoints(InputStream stream)
       throws ParserConfigurationException, SAXException, IOException {
     DefaultHandler splitPointHandler = parseXMLDocumentSplitPoints();
     SAXParserFactory splitPointsFactoryMain = SAXParserFactory.newInstance();
     splitPointsFactoryMain.setNamespaceAware(true);

     SAXParser saxParser = splitPointsFactoryMain.newSAXParser();
     saxParser.parse(stream, splitPointHandler);
   }

   public void startNewPermutation(String permutationId) {
     globalInformation = new GlobalInformation(permutationId);
     makeTopLevelHtmlForPerm = new MakeTopLevelHtmlForPerm(globalInformation,
         outDir);
   }

   private Collection<SizeBreakdown> breakdownsForFragment(Integer fragment) {
     List<SizeBreakdown> breakdowns = new ArrayList<SizeBreakdown>();
     breakdowns.add(globalInformation.getTotalCodeBreakdown());
     if (fragment == 0) {
       breakdowns.add(globalInformation.getInitialCodeBreakdown());
     }
     if (fragment == (globalInformation.getNumFragments() + 1)) {
       breakdowns.add(globalInformation.getLeftoversBreakdown());
     }
     if (fragment >= 1 && fragment <= globalInformation.getNumFragments()) {
       breakdowns.add(globalInformation.fragmentCodeBreakdown(fragment));
     }
     return breakdowns;
   }

   private DependencyLinker chooseDependencyLinker(SizeBreakdown breakdown) {
     if (globalInformation.dependencies == null) {
       // no dependencies are available
       return new NullDependencyLinker();
     }

     if (breakdown == globalInformation.getTotalCodeBreakdown()) {
       if (globalInformation.getNumFragments() > 0) {
         return makeTopLevelHtmlForPerm.new DependencyLinkerForTotalBreakdown();
       } else {
         return makeTopLevelHtmlForPerm.new DependencyLinkerForInitialCode();
       }
     } else if (breakdown == globalInformation.getInitialCodeBreakdown()) {
       return makeTopLevelHtmlForPerm.new DependencyLinkerForInitialCode();
     } else if (breakdown == globalInformation.getLeftoversBreakdown()) {
       assert globalInformation.getNumFragments() > 0;
       return makeTopLevelHtmlForPerm.new DependencyLinkerForLeftoversFragment();
     } else {
       return new NullDependencyLinker();
     }
   }

   /**
    * Generates all the HTML files for one size breakdown.
    */
   private void makeHTMLFiles(MakeTopLevelHtmlForPerm makeTopLevelHtmlForPerm,
       SizeBreakdown breakdown, DependencyLinker depLinker) throws IOException {
     makeTopLevelHtmlForPerm.makePackageClassesHtmls(breakdown, depLinker);
     makeTopLevelHtmlForPerm.makeCodeTypeClassesHtmls(breakdown);
     makeTopLevelHtmlForPerm.makeLiteralsClassesTableHtmls(breakdown);
     makeTopLevelHtmlForPerm.makeBreakdownShell(breakdown);
     makeTopLevelHtmlForPerm.makeTopLevelShell();
   }

   private DefaultHandler parseXMLDocumentSizeMap(
       final GlobalInformation globalInformation) {
     return new DefaultHandler() {
       int fragment = -1;

       @Override
       public void endElement(String uri, String localName, String qName) {
         if (localName.compareTo("sizemap") == 0) {
           fragment = -1;
         }
       }

       @Override
       public void startElement(String uri, String localName, String qName,
           final Attributes attributes) {
         if (localName.compareTo("sizemap") == 0) {
           // starting a new size map
           String fragString = attributes.getValue("fragment");
           if (fragString == null) {
             throw new FormatException();
           }
           try {
             fragment = Integer.valueOf(fragString);
           } catch (NumberFormatException e) {
             throw new FormatException(e);
           }
           String sizeString = attributes.getValue("size");
           if (sizeString == null) {
             throw new FormatException();
           }
           int size;
           try {
             size = Integer.valueOf(sizeString);
           } catch (NumberFormatException e) {
             throw new FormatException(e);
           }
           for (SizeBreakdown breakdown : breakdownsForFragment(fragment)) {
             breakdown.sizeAllCode += size;
           }
         } else if (localName.compareTo("size") == 0) {
           String type = attributes.getValue("type");
           if (type == null) {
             throw new FormatException();
           }
           String ref = attributes.getValue("ref");
           if (ref == null) {
             throw new FormatException();
           }
           String sizeString = attributes.getValue("size");
           if (sizeString == null) {
             throw new FormatException();
           }
           int size;
           try {
             size = Integer.valueOf(sizeString);
           } catch (NumberFormatException e) {
             throw new FormatException(e);
           }
           recordSize(type, ref, size, globalInformation);
         }
       }

       private void accountForSize(SizeBreakdown breakdown, String refType,
           String ref, int size, GlobalInformation globalInformation) {
         if (refType.equals("string")) {
           LiteralsCollection stringLiterals = breakdown.nameToLitColl.get("string");
           stringLiterals.size += size;
           stringLiterals.literals.add(ref);
         } else if (refType.equals("var")) {
           // Nothing to record, because no breakdown is provided for random
           // variables
         } else {
           if (!refType.equals("type") && !refType.equals("method") && !refType.equals("field")) {
             throw new FormatException();
           }

           if (refType.equals("method")) {
             breakdown.methodToSize.put(ref, Integer.valueOf(size));
           }

           String className = ref;
           if (className.contains("::")) {
             /*
              * It's a method or field reference. Discard the method/field part.
              */
             int idx = className.indexOf(':');
             className = className.substring(0, idx);
           }
           className = StringInterner.get().intern(className);
           // derive the package name from the class
           String packageName;
           if (!globalInformation.getClassToPackage().containsKey(className)) {
             packageName = className;
             packageName = packageName.replaceAll("\\.[A-Z].*", "");
             globalInformation.getClassToPackage().put(className, packageName);
           } else {
             packageName = globalInformation.getClassToPackage().get(className);
           }

           if (!globalInformation.getPackageToClasses().containsKey(packageName)) {
             TreeSet<String> insertSet = new TreeSet<String>();
             insertSet.add(className);
             globalInformation.getPackageToClasses().put(packageName, insertSet);
           } else {
             globalInformation.getPackageToClasses().get(packageName).add(
                 className);
           }

           recordClassCategories(breakdown.nameToCodeColl, className,
               packageName);

           if (breakdown.classToSize.containsKey(className)) {
             int newSize = breakdown.classToSize.get(className) + size;
             breakdown.classToSize.put(className, newSize);
           } else {
             breakdown.classToSize.put(className, size);
           }
         }
       }

       private void recordClassCategories(
           final HashMap<String, CodeCollection> nameToCodeColl,
           String className, String packageName) {
         if (packageName.startsWith("java")) {
           nameToCodeColl.get("jre").classes.add(className);
         } else if (packageName.startsWith("com.google.gwt.lang")) {
           nameToCodeColl.get("gwtLang").classes.add(className);
         }
         if (className.contains("_CustomFieldSerializer")) {
           nameToCodeColl.get("rpcUser").classes.add(className);
         } else if (className.endsWith("_FieldSerializer")
             || className.endsWith("_Proxy")
             || className.endsWith("_TypeSerializer")) {
           nameToCodeColl.get("rpcGen").classes.add(className);
         }
       }

       private void recordSize(String refType, String ref, int size,
           GlobalInformation globalInformation) {
         refType = StringInterner.get().intern(refType);
         ref = StringInterner.get().intern(ref);
         for (SizeBreakdown breakdown : breakdownsForFragment(fragment)) {
           accountForSize(breakdown, refType, ref, size, globalInformation);
         }
       }
     };
   }

   private DefaultHandler parseXMLDocumentSplitPoints() {
     DefaultHandler handler = new DefaultHandler() {

       private boolean inInitialLoadSequence = false;

       @Override
       public void endElement(String uri, String localName, String qName) {
         if (localName.compareTo("initialesq") == 0) {
           inInitialLoadSequence = false;
         }
       }

       @Override
       public void startElement(String nsUri, String strippedName,
           String tagName, final Attributes attributes) {
         if (strippedName.compareTo("splitpoint") == 0) {
           parseSplitPoint(attributes);
         } else if (strippedName.compareTo("initialseq") == 0) {
           inInitialLoadSequence = true;
         } else if (inInitialLoadSequence
             && strippedName.compareTo("splitpointref") == 0) {
           globalInformation.getInitialFragmentLoadSequence().add(
               parseSplitPointReference(attributes));
         }
       }

       /**
        * Parses a split point entry from a splitpoints XML soyc file.
        * A split point node as in \<splitpoint id=N location=DESC/\>
        *
        * @param attributes the attributes of the splitpoint node (provided by the SAX parsing
        *                   infrastructure)
        */
       private void parseSplitPoint(final Attributes attributes) {
         if (attributes.getValue("id") != null) {
           String curSplitPoint = attributes.getValue("id");
           if (attributes.getValue("location") != null) {
             String curSplitPointLocation = attributes.getValue("location");

             curSplitPointLocation = curSplitPointLocation.replaceAll("\\(L.*",
                 "");

             globalInformation.addFragmentDescriptor(
                 Integer.parseInt(curSplitPoint), curSplitPointLocation);
           }
         }
       }

       private Integer parseSplitPointReference(final Attributes attributes) {
         String spString = attributes.getValue("id");
         if (spString == null) {
           throw new FormatException("Could not parse split point reference");
         }
         return Integer.valueOf(spString);
       }

     };
     return handler;
   }

   /*
    * assigns code to "all other code" if none of the special categories apply
    */
   private void updateAllOtherCodeType(
       final HashMap<String, CodeCollection> nameToCodeColl) {
     // all classes not in any of the other categories
     for (String className : globalInformation.getClassToPackage().keySet()) {
       if ((!nameToCodeColl.get("widget").classes.contains(className))
           && (!nameToCodeColl.get("rpcUser").classes.contains(className))
           && (!nameToCodeColl.get("rpcGwt").classes.contains(className))
           && (!nameToCodeColl.get("rpcGen").classes.contains(className))
           && (!nameToCodeColl.get("jre").classes.contains(className))
           && (!nameToCodeColl.get("gwtLang").classes.contains(className))) {
         nameToCodeColl.get("allOther").classes.add(className);
       }
     }
   }
 }
	/*
	* Copyright 2008 Google Inc.
	*
	* 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.google.gwt.soyc;

	import com.google.gwt.core.ext.linker.CompilationMetricsArtifact;
	import com.google.gwt.core.ext.linker.ModuleMetricsArtifact;
	import com.google.gwt.core.ext.linker.PrecompilationMetricsArtifact;
	import com.google.gwt.dev.util.StringInterner;
	import com.google.gwt.soyc.MakeTopLevelHtmlForPerm.DependencyLinker;
	import com.google.gwt.soyc.MakeTopLevelHtmlForPerm.NullDependencyLinker;
	import com.google.gwt.soyc.io.OutputDirectory;

	import org.xml.sax.Attributes;
	import org.xml.sax.SAXException;
	import org.xml.sax.helpers.DefaultHandler;

	import java.io.IOException;
	import java.io.InputStream;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.Map.Entry;
	import java.util.TreeMap;
	import java.util.TreeSet;

	import javax.xml.parsers.ParserConfigurationException;
	import javax.xml.parsers.SAXParser;
	import javax.xml.parsers.SAXParserFactory;

	/**
	* The command-line entry point for creating a compile report.
	*/
	public class SoycDashboard {
	private static class FormatException extends RuntimeException {
	public FormatException() {
	super();
	}

	public FormatException(String message) {
	super(message);
	}

	public FormatException(Throwable cause) {
	super(cause);
	}
	}

	/*
	* cleans up the RPC code categories
	*/
	private static void foldInRPCHeuristic(
	final HashMap<String, CodeCollection> nameToCodeColl) {
	/**
	* Heuristic: this moves all classes that override serializable from RPC to
	* "Other Code" if there is no RPC generated code, i.e., if the
	* application really is not using RPC
	*/

	if (nameToCodeColl.get("rpcGen").classes.size() == 0) {

	for (String className : nameToCodeColl.get("rpcUser").classes) {

	if ((!nameToCodeColl.get("widget").classes.contains(className))
	&& (!nameToCodeColl.get("jre").classes.contains(className))
	&& (!nameToCodeColl.get("gwtLang").classes.contains(className))) {
	nameToCodeColl.get("allOther").classes.add(className);
	}
	}
	nameToCodeColl.get("rpcUser").classes.clear();

	for (String className : nameToCodeColl.get("rpcGwt").classes) {
	if ((!nameToCodeColl.get("widget").classes.contains(className))
	&& (!nameToCodeColl.get("jre").classes.contains(className))
	&& (!nameToCodeColl.get("gwtLang").classes.contains(className))) {
	nameToCodeColl.get("allOther").classes.add(className);
	}
	}
	nameToCodeColl.get("rpcGwt").classes.clear();
	}
	}

	private static DefaultHandler parseXMLDocumentDependencies(
	final Map<String, Map<String, String>> allDependencies) {
	DefaultHandler handler = new DefaultHandler() {

	// may want to create a class for this later
	String curMethod;
	Map<String, String> dependencies = new TreeMap<String, String>();
	String graphExtends = null;
	StringBuilder valueBuilder = new StringBuilder();

	@Override
	public void endElement(String uri, String localName, String qName) {
	if (localName.compareTo("table") == 0) {
	if (graphExtends != null) {
	// Add in elements from the extended graph
	for (Entry<String, String> entry : allDependencies.get(graphExtends).entrySet()) {
	dependencies.put(entry.getKey(), entry.getValue());
	}
	}
	}
	}

	@Override
	public void startElement(String nsUri, String strippedName,
	String tagName, final Attributes attributes) {

	valueBuilder.delete(0, valueBuilder.length());

	if (strippedName.compareTo("table") == 0
	&& (attributes.getValue("name") != null)) {
	String name = attributes.getValue("name");
	dependencies = new TreeMap<String, String>();
	allDependencies.put(StringInterner.get().intern(name), dependencies);
	if (attributes.getValue("extends") != null) {
	graphExtends = StringInterner.get().intern(attributes.getValue("extends"));
	if (!allDependencies.containsKey(graphExtends)) {
	throw new FormatException("Graph " + name
	+ " extends an unknown graph " + graphExtends);
	}
	} else {
	graphExtends = null;
	}
	} else if ((strippedName.compareTo("method") == 0)
	&& (attributes.getValue("name") != null)) {
	curMethod = StringInterner.get().intern(attributes.getValue("name"));
	} else if ((strippedName.compareTo("called") == 0)
	&& (attributes.getValue("by") != null)) {
	String curDepMethod = attributes.getValue("by");
	if (!dependencies.containsKey(curMethod)) {
	dependencies.put(StringInterner.get().intern(curMethod),
	StringInterner.get().intern(curDepMethod));
	}
	}
	}
	};
	return handler;
	}

	/**
	* Global information for the current permutation being emitted.
	*/
	private GlobalInformation globalInformation;

	/**
	* HTML emitter for the current permutation being emitted.
	*/
	private MakeTopLevelHtmlForPerm makeTopLevelHtmlForPerm;

	private final OutputDirectory outDir;

	public SoycDashboard(OutputDirectory outDir) {
	this.outDir = outDir;
	}

	public void generateCompilerMetricsForOnePermutation(
	ModuleMetricsArtifact moduleMetrics,
	PrecompilationMetricsArtifact precompilationMetrics,
	CompilationMetricsArtifact compilationMetrics) throws IOException {
	makeTopLevelHtmlForPerm.makeCompilerMetricsPermFiles(moduleMetrics,
	precompilationMetrics, compilationMetrics);
	}

	public void generateCrossPermutationFiles(Map<String, List<String>> permInfo)
	throws IOException {
	StaticResources.emit(outDir);
	MakeTopLevelHtmlForPerm.makeTopLevelHtmlForAllPerms(permInfo, outDir);
	}

	public void generateForOnePermutation() throws IOException {
	if (globalInformation.dependencies != null) {
	makeTopLevelHtmlForPerm.makeDependenciesHtml();
	}

	if (globalInformation.getNumFragments() > 0) {
	makeTopLevelHtmlForPerm.makeSplitStatusPages();
	makeTopLevelHtmlForPerm.makeLeftoverStatusPages();
	}
	for (SizeBreakdown breakdown : globalInformation.allSizeBreakdowns()) {
	DependencyLinker linker = chooseDependencyLinker(breakdown);
	makeHTMLFiles(makeTopLevelHtmlForPerm, breakdown, linker);
	}
	}

	public void readDependencies(InputStream stream)
	throws ParserConfigurationException, SAXException, IOException {
	globalInformation.dependencies = new TreeMap<String, Map<String, String>>();
	DefaultHandler depHandler = parseXMLDocumentDependencies(globalInformation.dependencies);
	SAXParserFactory depFactoryMain = SAXParserFactory.newInstance();
	depFactoryMain.setNamespaceAware(true);
	SAXParser saxParser = depFactoryMain.newSAXParser();
	saxParser.parse(stream, depHandler);
	}

	public void readSizeMaps(InputStream stream)
	throws ParserConfigurationException, SAXException, IOException {
	DefaultHandler handler = parseXMLDocumentSizeMap(globalInformation);
	SAXParserFactory factoryMain = SAXParserFactory.newInstance();
	factoryMain.setNamespaceAware(true);
	SAXParser saxParser = factoryMain.newSAXParser();
	saxParser.parse(stream, handler);

	// Now clean up the information that has been read in various ways
	globalInformation.computePackageSizes();

	// add to "All Other Code" if none of the special categories apply
	for (SizeBreakdown breakdown : globalInformation.allSizeBreakdowns()) {
	updateAllOtherCodeType(breakdown.nameToCodeColl);
	}

	// clean up the RPC categories
	for (SizeBreakdown breakdown : globalInformation.allSizeBreakdowns()) {
	foldInRPCHeuristic(breakdown.nameToCodeColl);
	}
	}

	public void readSplitPoints(InputStream stream)
	throws ParserConfigurationException, SAXException, IOException {
	DefaultHandler splitPointHandler = parseXMLDocumentSplitPoints();
	SAXParserFactory splitPointsFactoryMain = SAXParserFactory.newInstance();
	splitPointsFactoryMain.setNamespaceAware(true);

	SAXParser saxParser = splitPointsFactoryMain.newSAXParser();
	saxParser.parse(stream, splitPointHandler);
	}

	public void startNewPermutation(String permutationId) {
	globalInformation = new GlobalInformation(permutationId);
	makeTopLevelHtmlForPerm = new MakeTopLevelHtmlForPerm(globalInformation,
	outDir);
	}

	private Collection<SizeBreakdown> breakdownsForFragment(Integer fragment) {
	List<SizeBreakdown> breakdowns = new ArrayList<SizeBreakdown>();
	breakdowns.add(globalInformation.getTotalCodeBreakdown());
	if (fragment == 0) {
	breakdowns.add(globalInformation.getInitialCodeBreakdown());
	}
	if (fragment == (globalInformation.getNumFragments() + 1)) {
	breakdowns.add(globalInformation.getLeftoversBreakdown());
	}
	if (fragment >= 1 && fragment <= globalInformation.getNumFragments()) {
	breakdowns.add(globalInformation.fragmentCodeBreakdown(fragment));
	}
	return breakdowns;
	}

	private DependencyLinker chooseDependencyLinker(SizeBreakdown breakdown) {
	if (globalInformation.dependencies == null) {
	// no dependencies are available
	return new NullDependencyLinker();
	}

	if (breakdown == globalInformation.getTotalCodeBreakdown()) {
	if (globalInformation.getNumFragments() > 0) {
	return makeTopLevelHtmlForPerm.new DependencyLinkerForTotalBreakdown();
	} else {
	return makeTopLevelHtmlForPerm.new DependencyLinkerForInitialCode();
	}
	} else if (breakdown == globalInformation.getInitialCodeBreakdown()) {
	return makeTopLevelHtmlForPerm.new DependencyLinkerForInitialCode();
	} else if (breakdown == globalInformation.getLeftoversBreakdown()) {
	assert globalInformation.getNumFragments() > 0;
	return makeTopLevelHtmlForPerm.new DependencyLinkerForLeftoversFragment();
	} else {
	return new NullDependencyLinker();
	}
	}

	/**
	* Generates all the HTML files for one size breakdown.
	*/
	private void makeHTMLFiles(MakeTopLevelHtmlForPerm makeTopLevelHtmlForPerm,
	SizeBreakdown breakdown, DependencyLinker depLinker) throws IOException {
	makeTopLevelHtmlForPerm.makePackageClassesHtmls(breakdown, depLinker);
	makeTopLevelHtmlForPerm.makeCodeTypeClassesHtmls(breakdown);
	makeTopLevelHtmlForPerm.makeLiteralsClassesTableHtmls(breakdown);
	makeTopLevelHtmlForPerm.makeBreakdownShell(breakdown);
	makeTopLevelHtmlForPerm.makeTopLevelShell();
	}

	private DefaultHandler parseXMLDocumentSizeMap(
	final GlobalInformation globalInformation) {
	return new DefaultHandler() {
	int fragment = -1;

	@Override
	public void endElement(String uri, String localName, String qName) {
	if (localName.compareTo("sizemap") == 0) {
	fragment = -1;
	}
	}

	@Override
	public void startElement(String uri, String localName, String qName,
	final Attributes attributes) {
	if (localName.compareTo("sizemap") == 0) {
	// starting a new size map
	String fragString = attributes.getValue("fragment");
	if (fragString == null) {
	throw new FormatException();
	}
	try {
	fragment = Integer.valueOf(fragString);
	} catch (NumberFormatException e) {
	throw new FormatException(e);
	}
	String sizeString = attributes.getValue("size");
	if (sizeString == null) {
	throw new FormatException();
	}
	int size;
	try {
	size = Integer.valueOf(sizeString);
	} catch (NumberFormatException e) {
	throw new FormatException(e);
	}
	for (SizeBreakdown breakdown : breakdownsForFragment(fragment)) {
	breakdown.sizeAllCode += size;
	}
	} else if (localName.compareTo("size") == 0) {
	String type = attributes.getValue("type");
	if (type == null) {
	throw new FormatException();
	}
	String ref = attributes.getValue("ref");
	if (ref == null) {
	throw new FormatException();
	}
	String sizeString = attributes.getValue("size");
	if (sizeString == null) {
	throw new FormatException();
	}
	int size;
	try {
	size = Integer.valueOf(sizeString);
	} catch (NumberFormatException e) {
	throw new FormatException(e);
	}
	recordSize(type, ref, size, globalInformation);
	}
	}

	private void accountForSize(SizeBreakdown breakdown, String refType,
	String ref, int size, GlobalInformation globalInformation) {
	if (refType.equals("string")) {
	LiteralsCollection stringLiterals = breakdown.nameToLitColl.get("string");
	stringLiterals.size += size;
	stringLiterals.literals.add(ref);
	} else if (refType.equals("var")) {
	// Nothing to record, because no breakdown is provided for random
	// variables
	} else {
	if (!refType.equals("type") && !refType.equals("method") && !refType.equals("field")) {
	throw new FormatException();
	}

	if (refType.equals("method")) {
	breakdown.methodToSize.put(ref, Integer.valueOf(size));
	}

	String className = ref;
	if (className.contains("::")) {
	/*
	* It's a method or field reference. Discard the method/field part.
	*/
	int idx = className.indexOf(':');
	className = className.substring(0, idx);
	}
	className = StringInterner.get().intern(className);
	// derive the package name from the class
	String packageName;
	if (!globalInformation.getClassToPackage().containsKey(className)) {
	packageName = className;
	packageName = packageName.replaceAll("\\.[A-Z].*", "");
	globalInformation.getClassToPackage().put(className, packageName);
	} else {
	packageName = globalInformation.getClassToPackage().get(className);
	}

	if (!globalInformation.getPackageToClasses().containsKey(packageName)) {
	TreeSet<String> insertSet = new TreeSet<String>();
	insertSet.add(className);
	globalInformation.getPackageToClasses().put(packageName, insertSet);
	} else {
	globalInformation.getPackageToClasses().get(packageName).add(
	className);
	}

	recordClassCategories(breakdown.nameToCodeColl, className,
	packageName);

	if (breakdown.classToSize.containsKey(className)) {
	int newSize = breakdown.classToSize.get(className) + size;
	breakdown.classToSize.put(className, newSize);
	} else {
	breakdown.classToSize.put(className, size);
	}
	}
	}

	private void recordClassCategories(
	final HashMap<String, CodeCollection> nameToCodeColl,
	String className, String packageName) {
	if (packageName.startsWith("java")) {
	nameToCodeColl.get("jre").classes.add(className);
	} else if (packageName.startsWith("com.google.gwt.lang")) {
	nameToCodeColl.get("gwtLang").classes.add(className);
	}
	if (className.contains("_CustomFieldSerializer")) {
	nameToCodeColl.get("rpcUser").classes.add(className);
	} else if (className.endsWith("_FieldSerializer")
	\|\| className.endsWith("_Proxy")
	\|\| className.endsWith("_TypeSerializer")) {
	nameToCodeColl.get("rpcGen").classes.add(className);
	}
	}

	private void recordSize(String refType, String ref, int size,
	GlobalInformation globalInformation) {
	refType = StringInterner.get().intern(refType);
	ref = StringInterner.get().intern(ref);
	for (SizeBreakdown breakdown : breakdownsForFragment(fragment)) {
	accountForSize(breakdown, refType, ref, size, globalInformation);
	}
	}
	};
	}

	private DefaultHandler parseXMLDocumentSplitPoints() {
	DefaultHandler handler = new DefaultHandler() {

	private boolean inInitialLoadSequence = false;

	@Override
	public void endElement(String uri, String localName, String qName) {
	if (localName.compareTo("initialesq") == 0) {
	inInitialLoadSequence = false;
	}
	}

	@Override
	public void startElement(String nsUri, String strippedName,
	String tagName, final Attributes attributes) {
	if (strippedName.compareTo("splitpoint") == 0) {
	parseSplitPoint(attributes);
	} else if (strippedName.compareTo("initialseq") == 0) {
	inInitialLoadSequence = true;
	} else if (inInitialLoadSequence
	&& strippedName.compareTo("splitpointref") == 0) {
	globalInformation.getInitialFragmentLoadSequence().add(
	parseSplitPointReference(attributes));
	}
	}

	/**
	* Parses a split point entry from a splitpoints XML soyc file.
	* A split point node as in \<splitpoint id=N location=DESC/\>
	*
	* @param attributes the attributes of the splitpoint node (provided by the SAX parsing
	* infrastructure)
	*/
	private void parseSplitPoint(final Attributes attributes) {
	if (attributes.getValue("id") != null) {
	String curSplitPoint = attributes.getValue("id");
	if (attributes.getValue("location") != null) {
	String curSplitPointLocation = attributes.getValue("location");

	curSplitPointLocation = curSplitPointLocation.replaceAll("\\(L.*",
	"");

	globalInformation.addFragmentDescriptor(
	Integer.parseInt(curSplitPoint), curSplitPointLocation);
	}
	}
	}

	private Integer parseSplitPointReference(final Attributes attributes) {
	String spString = attributes.getValue("id");
	if (spString == null) {
	throw new FormatException("Could not parse split point reference");
	}
	return Integer.valueOf(spString);
	}

	};
	return handler;
	}

	/*
	* assigns code to "all other code" if none of the special categories apply
	*/
	private void updateAllOtherCodeType(
	final HashMap<String, CodeCollection> nameToCodeColl) {
	// all classes not in any of the other categories
	for (String className : globalInformation.getClassToPackage().keySet()) {
	if ((!nameToCodeColl.get("widget").classes.contains(className))
	&& (!nameToCodeColl.get("rpcUser").classes.contains(className))
	&& (!nameToCodeColl.get("rpcGwt").classes.contains(className))
	&& (!nameToCodeColl.get("rpcGen").classes.contains(className))
	&& (!nameToCodeColl.get("jre").classes.contains(className))
	&& (!nameToCodeColl.get("gwtLang").classes.contains(className))) {
	nameToCodeColl.get("allOther").classes.add(className);
	}
	}
	}
	}