| /* |
| * 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 org.xml.sax.*; |
| import org.xml.sax.helpers.*; |
| import org.xml.sax.SAXException; |
| |
| import java.io.*; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Map; |
| import java.util.TreeSet; |
| import java.util.TreeMap; |
| import java.util.zip.GZIPInputStream; |
| import javax.xml.parsers.*; |
| |
| public class SoycDashboard { |
| |
| /** |
| * @param args Input: XML file containing soyc compile output |
| * @throws IOException |
| * @throws SAXException |
| */ |
| public static void main(String[] args) { |
| |
| String inFileName = ""; |
| String depInFileName = ""; |
| if ((args.length != 1) && (args.length != 2)){ |
| |
| if (args.length == 1){ |
| GlobalInformation.displayDependencies = false; |
| } |
| else{ |
| GlobalInformation.displayDependencies = true; |
| depInFileName = args[1]; |
| } |
| |
| System.err.println("Usage: java com/google/gwt/soyc/SoycDashboard soyc-report0.xml[.gz] soyc-dependencies0.xml[.gz] OR java com/google/gwt/soyc/SoycDashboard soyc-report0.xml[.gz]"); |
| System.exit(1); |
| } |
| |
| inFileName = args[0]; |
| |
| |
| |
| if (GlobalInformation.displayDependencies == true){ |
| /** |
| * handle dependencies |
| */ |
| |
| Map<String, ArrayList<String>> dependencies = new TreeMap<String, ArrayList<String>>(); |
| DefaultHandler depHandler = parseXMLDocumentDependencies(dependencies); |
| |
| // start parsing |
| SAXParserFactory depFactoryMain = SAXParserFactory.newInstance(); |
| depFactoryMain.setNamespaceAware(true); |
| try { |
| SAXParser saxParser = depFactoryMain.newSAXParser(); |
| InputStream in = new FileInputStream(depInFileName); |
| if (depInFileName.endsWith(".gz")) { |
| in = new GZIPInputStream(in); |
| } |
| in = new BufferedInputStream(in); |
| saxParser.parse(in,depHandler); |
| } catch (ParserConfigurationException e) { |
| throw new RuntimeException("Could not parse document. ", e); |
| } catch (SAXException e) { |
| throw new RuntimeException("Could not create SAX parser. ", e); |
| } catch (FileNotFoundException e) { |
| throw new RuntimeException("Could not open file. ", e); |
| } catch (IOException e) { |
| throw new RuntimeException("Could not open file. ", e); |
| } |
| |
| try{ |
| MakeTopLevelHtmlForPerm.makeDependenciesHtml(dependencies); |
| } catch (IOException e) { |
| throw new RuntimeException("Cannot open file. ", e); |
| } |
| } |
| |
| /** |
| * handle everything else |
| */ |
| |
| // to store literals data |
| GlobalInformation.nameToLitColl.put("long",new LiteralsCollection("long")); |
| GlobalInformation.nameToLitColl.put("null",new LiteralsCollection("null")); |
| GlobalInformation.nameToLitColl.put("class",new LiteralsCollection("class")); |
| GlobalInformation.nameToLitColl.put("int",new LiteralsCollection("int")); |
| GlobalInformation.nameToLitColl.put("string",new LiteralsCollection("string")); |
| GlobalInformation.nameToLitColl.put("number",new LiteralsCollection("number")); |
| GlobalInformation.nameToLitColl.put("boolean",new LiteralsCollection("boolean")); |
| GlobalInformation.nameToLitColl.put("double",new LiteralsCollection("double")); |
| GlobalInformation.nameToLitColl.put("char",new LiteralsCollection("char")); |
| GlobalInformation.nameToLitColl.put("undefined",new LiteralsCollection("undefined")); |
| GlobalInformation.nameToLitColl.put("float",new LiteralsCollection("float")); |
| |
| // to store code data |
| GlobalInformation.nameToCodeColl.put("allOther", new CodeCollection("allOther")); |
| GlobalInformation.nameToCodeColl.put("widget", new CodeCollection("widget")); |
| GlobalInformation.nameToCodeColl.put("rpcUser", new CodeCollection("rpcUser")); |
| GlobalInformation.nameToCodeColl.put("rpcGen", new CodeCollection("rpcGen")); |
| GlobalInformation.nameToCodeColl.put("rpcGwt", new CodeCollection("rpcGwt")); |
| GlobalInformation.nameToCodeColl.put("gwtLang", new CodeCollection("long")); |
| GlobalInformation.nameToCodeColl.put("jre", new CodeCollection("jre")); |
| |
| |
| // make the parser handler |
| DefaultHandler handler = parseXMLDocument(GlobalInformation.nameToLitColl, GlobalInformation.nameToCodeColl); |
| |
| |
| // start parsing |
| SAXParserFactory factoryMain = SAXParserFactory.newInstance(); |
| factoryMain.setNamespaceAware(true); |
| try { |
| SAXParser saxParser = factoryMain.newSAXParser(); |
| InputStream in = new FileInputStream(inFileName); |
| if (inFileName.endsWith(".gz")) { |
| in = new GZIPInputStream(in); |
| } |
| in = new BufferedInputStream(in); |
| saxParser.parse(in,handler); |
| } catch (ParserConfigurationException e) { |
| throw new RuntimeException("Could not parse document. ", e); |
| } catch (SAXException e) { |
| throw new RuntimeException("Could not create SAX parser. ", e); |
| } catch (FileNotFoundException e) { |
| throw new RuntimeException("Could not open file. ", e); |
| } catch (IOException e) { |
| throw new RuntimeException("Could not open file. ", e); |
| } |
| |
| // add to "All Other Code" if none of the special categories apply |
| updateAllOtherCodeType(GlobalInformation.nameToCodeColl); |
| |
| // now we need to aggregate numbers |
| GlobalInformation.computePackageSizes(); |
| GlobalInformation.computePartialPackageSizes(); |
| |
| // clean up the RPC categories |
| foldInRPCHeuristic(GlobalInformation.nameToCodeColl); |
| |
| // generate all the html files |
| makeHTMLFiles(GlobalInformation.nameToLitColl, GlobalInformation.nameToCodeColl); |
| |
| System.out.println("Finished creating reports. To see the dashboard, open SoycDashboard-index.html in your browser."); |
| } |
| |
| |
| private static DefaultHandler parseXMLDocument( |
| final TreeMap<String, LiteralsCollection> nameToLitColl, |
| final HashMap<String, CodeCollection> nameToCodeColl) { |
| |
| DefaultHandler handler = new DefaultHandler() { |
| |
| String curStoryId; |
| String curStoryLiteralType; |
| String curLineNumber; |
| String curLocation; |
| String curStoryRef; |
| HashSet<String> curRelevantLitTypes = new HashSet<String>(); |
| HashSet<String> curRelevantCodeTypes = new HashSet<String>(); |
| String curClassId; |
| String curPackage; |
| Integer curFragment; |
| String curFunctionId = ""; |
| boolean specialCodeType = false; |
| StringBuilder valueBuilder = new StringBuilder(); |
| int ct = 0; |
| boolean fragmentInLoadOrder = false; |
| |
| /** |
| * This method deals with the beginning of the XML element. |
| * It analyzes the XML node and adds its information to the relevant literal or code collection for later analysis. |
| * @see org.xml.sax.helpers.DefaultHandler#startElement(java.lang.String, java.lang.String, java.lang.String, org.xml.sax.Attributes) |
| */ |
| @Override |
| public void startElement(String nsUri, String strippedName, String tagName, Attributes attributes) { |
| |
| if ((ct % 10000) == 0){ |
| System.out.println(ct); |
| } |
| ct++; |
| |
| valueBuilder.delete(0,valueBuilder.length()); |
| |
| if (strippedName.compareTo("splitpoint") == 0){ |
| System.out.println("about to process splitpoint"); |
| parseSplitPoint(attributes); |
| } |
| else if ((strippedName.compareTo("package") == 0)&&(attributes.getValue("id") != null)){ |
| curPackage = attributes.getValue("id"); |
| |
| if (curPackage.compareTo("") == 0){ |
| curPackage = "emptyPackageName"; |
| } |
| |
| if (! GlobalInformation.packageToClasses.containsKey(curPackage)){ |
| TreeSet<String> insertSet = new TreeSet<String>(); |
| GlobalInformation.packageToClasses.put(curPackage, insertSet); |
| } |
| } |
| |
| else if (strippedName.compareTo("class") == 0){ |
| |
| parseClass(nameToCodeColl, attributes); |
| } |
| |
| else if (strippedName.compareTo("function") == 0){ |
| if (attributes.getValue("id") != null){ |
| curFunctionId = attributes.getValue("id"); |
| } |
| } |
| |
| //TODO(kprobst): not currently used, but will be for dependencies |
| else if (strippedName.compareTo("on") == 0){ |
| parseDependsOn(nameToCodeColl, attributes); |
| } |
| |
| else if (strippedName.compareTo("of") == 0){ |
| parseOverrides(nameToCodeColl, attributes); |
| } |
| |
| else if (strippedName.compareTo("by") == 0){ |
| parseCorrelations(nameToCodeColl, attributes); |
| } |
| |
| else if (strippedName.compareTo("story") == 0){ |
| parseStory(attributes); |
| } |
| |
| else if (strippedName.compareTo("origin") == 0){ |
| parseOrigins(nameToLitColl, attributes); |
| } |
| |
| else if (strippedName.compareTo("js") == 0){ |
| if (attributes.getValue("fragment") != null){ |
| // ignore all code that is not in the first load order |
| |
| curFragment = Integer.parseInt(attributes.getValue("fragment")); |
| if((curFragment == 0)|| |
| (curFragment == (GlobalInformation.numSplitPoints+1))|| |
| (curFragment == (GlobalInformation.numSplitPoints+2))|| |
| ((curFragment >= 2) && (curFragment <= GlobalInformation.numSplitPoints))){ |
| fragmentInLoadOrder = true; |
| } |
| else{ |
| fragmentInLoadOrder = false; |
| } |
| } |
| else{ |
| |
| curFragment = -2; |
| } |
| } |
| |
| else if (strippedName.compareTo("storyref") == 0){ |
| parseJs(nameToLitColl, nameToCodeColl, attributes, curFragment); |
| } |
| } |
| |
| |
| /** |
| * This method collects a block of the value of the current XML node that the SAX parser parses. |
| * It simply adds to the the previous blocks, so that we can collect the entire value block. |
| */ |
| @Override |
| public void characters (char ch[], int start, int length){ |
| valueBuilder.append(ch, start, length); |
| } |
| |
| |
| /** |
| * This method marks the end of an XML element that the SAX parser parses. |
| * It has access to the full value of the node and uses it add information to the relevant literal or code collections. |
| * @see org.xml.sax.helpers.DefaultHandler#endElement(java.lang.String, java.lang.String, java.lang.String) |
| */ |
| @Override |
| public void endElement (String nsUri, String strippedName, String qName){ |
| String value = valueBuilder.toString(); |
| |
| int numBytes = value.getBytes().length; |
| |
| if (curStoryRef != null){ |
| |
| //add this size to the current fragment |
| if (GlobalInformation.storiesToCorrClasses.containsKey(curStoryRef)){ |
| |
| if ((GlobalInformation.storiesToLitType.containsKey(curStoryRef))&&(GlobalInformation.storiesToCorrClasses.get(curStoryRef).size() > 0)){ |
| GlobalInformation.numBytesDoubleCounted += numBytes; |
| } |
| |
| float partialSize = (float)numBytes / (float)GlobalInformation.storiesToCorrClasses.get(curStoryRef).size(); |
| if (!GlobalInformation.fragmentToPartialSize.containsKey(curFragment)){ |
| GlobalInformation.fragmentToPartialSize.put(curFragment, partialSize); |
| } |
| else{ |
| float newSize = GlobalInformation.fragmentToPartialSize.get(curFragment) + partialSize; |
| GlobalInformation.fragmentToPartialSize.put(curFragment, newSize); |
| } |
| |
| // now do different things depending on whether this fragment is in the load order or not |
| if (fragmentInLoadOrder == false){ |
| GlobalInformation.allOtherFragmentsPartialSize += numBytes; |
| } |
| else{ |
| GlobalInformation.cumSizeAllCode += numBytes; |
| |
| if ((!GlobalInformation.storiesToLitType.containsKey(curStoryRef))&& |
| (!GlobalInformation.storiesToCorrClasses.containsKey(curStoryRef))){ |
| GlobalInformation.nonAttributedStories.add(curStoryRef); |
| GlobalInformation.nonAttributedBytes += numBytes; |
| } |
| |
| |
| // go through all the classes for this story |
| for (String className : GlobalInformation.storiesToCorrClasses.get(curStoryRef)){ |
| // get the corresponding package |
| if (GlobalInformation.classToPackage.containsKey(className)){ |
| String packageName = GlobalInformation.classToPackage.get(className); |
| |
| if (!GlobalInformation.packageToClasses.containsKey(packageName)){ |
| TreeSet<String> insertSet = new TreeSet<String>(); |
| insertSet.add(className); |
| GlobalInformation.packageToClasses.put(packageName, insertSet); |
| } |
| else{ |
| GlobalInformation.packageToClasses.get(packageName).add(className); |
| } |
| |
| if (GlobalInformation.classToSize.containsKey(className)){ |
| int newSize = GlobalInformation.classToSize.get(className) + numBytes; |
| GlobalInformation.classToSize.put(className, newSize); |
| } |
| else{ |
| GlobalInformation.classToSize.put(className, numBytes); |
| } |
| |
| if (GlobalInformation.classToPartialSize.containsKey(className)){ |
| float newSize = GlobalInformation.classToPartialSize.get(className) + partialSize; |
| GlobalInformation.classToPartialSize.put(className, newSize); |
| } |
| else{ |
| GlobalInformation.classToPartialSize.put(className, partialSize); |
| } |
| } |
| } |
| } |
| } |
| updateLitTypes(nameToLitColl, value, numBytes); |
| } |
| } |
| |
| |
| /* |
| * This method assigns strings to the appropriate category |
| */ |
| private void updateLitTypes( |
| final TreeMap<String, LiteralsCollection> nameToLitColl, |
| String value, int numBytes) { |
| |
| int iNumCounted = 0; |
| |
| for (String relLitType : curRelevantLitTypes){ |
| iNumCounted++; |
| |
| //then give string literals special treatment |
| if (relLitType.compareTo("string") == 0){ |
| |
| // note that this will double-count (i.e., it will count a string twice if it's in the output twice), as it should. |
| nameToLitColl.get("string").cumStringSize += numBytes; |
| nameToLitColl.get(relLitType).cumSize += numBytes; |
| |
| //get the origins |
| HashSet<String> originSet = nameToLitColl.get("string").storyToLocations.get(curStoryRef); |
| |
| // find the most appropriate string literal category |
| String mostAppropriateCategory = ""; |
| String mostAppropriateLocation = ""; |
| String backupLocation = ""; |
| for (String origin : originSet){ |
| |
| if ((origin.contains("ClassLiteralHolder")) && (mostAppropriateCategory.compareTo("") == 0)){ |
| mostAppropriateCategory = "compiler"; |
| mostAppropriateLocation = origin; |
| } |
| else if ((origin.startsWith("transient source for"))&&(origin.contains("_TypeSerializer")) && (mostAppropriateCategory.compareTo("") == 0)){ |
| mostAppropriateCategory = "transient"; |
| mostAppropriateLocation = origin; |
| } |
| else if ((origin.contains("InlineResourceBundleGenerator")) && (mostAppropriateCategory.compareTo("") == 0)){ |
| mostAppropriateCategory = "inlinedTextRes"; |
| mostAppropriateLocation = origin; |
| } |
| if (origin.compareTo("com.google.gwt.dev.js.ast.JsProgram: Line 0") != 0){ |
| backupLocation = origin; |
| } |
| } |
| |
| if (backupLocation.compareTo("") == 0){ |
| backupLocation = "com.google.gwt.dev.js.ast.JsProgram: Line 0"; |
| } |
| if ((((value.startsWith("'")) && (value.endsWith("'"))) || |
| ((value.startsWith("\""))&&(value.endsWith("\"")))) && |
| (mostAppropriateCategory.compareTo("") == 0)){ |
| mostAppropriateCategory = "user"; |
| mostAppropriateLocation = backupLocation; |
| } |
| else if (mostAppropriateCategory.compareTo("") == 0){ |
| mostAppropriateCategory = "otherStrings"; |
| mostAppropriateLocation = backupLocation; |
| } |
| |
| if (!nameToLitColl.get("string").stringLiteralToType.containsKey(value)){ |
| nameToLitColl.get("string").stringLiteralToType.put(value, mostAppropriateCategory); |
| if (!nameToLitColl.get("string").stringTypeToCount.containsKey(mostAppropriateCategory)){ |
| nameToLitColl.get("string").stringTypeToCount.put(mostAppropriateCategory, 1); |
| } |
| else{ |
| int iNewCount = nameToLitColl.get("string").stringTypeToCount.get(mostAppropriateCategory) + 1; |
| nameToLitColl.get("string").stringTypeToCount.put(mostAppropriateCategory, iNewCount); |
| } |
| |
| |
| int iNewSize = numBytes; |
| if (nameToLitColl.get("string").stringTypeToSize.containsKey(mostAppropriateCategory)){ |
| iNewSize += nameToLitColl.get("string").stringTypeToSize.get(mostAppropriateCategory); |
| } |
| nameToLitColl.get("string").stringTypeToSize.put(mostAppropriateCategory, iNewSize); |
| |
| |
| if (nameToLitColl.get("string").storyToLocations.containsKey(curStoryRef)){ |
| HashSet<String> insertSet = new HashSet<String>(); |
| insertSet.add(mostAppropriateLocation); |
| nameToLitColl.get(relLitType).literalToLocations.put(value,insertSet); |
| } |
| } |
| } |
| |
| else{ |
| // note that this will double-count (i.e., it will count a literal twice if it's in the output twice), as it should. |
| nameToLitColl.get(relLitType).cumSize += numBytes; |
| |
| if (nameToLitColl.get(relLitType).storyToLocations.containsKey(curStoryRef)){ |
| if (nameToLitColl.get(relLitType).literalToLocations.containsKey(value)){ |
| nameToLitColl.get(relLitType).literalToLocations.get(value).addAll(nameToLitColl.get(relLitType). |
| storyToLocations.get(curStoryRef)); |
| } |
| else{ |
| HashSet<String> insertSet = nameToLitColl.get(relLitType).storyToLocations.get(curStoryRef); |
| nameToLitColl.get(relLitType).literalToLocations.put(value,insertSet); |
| } |
| |
| } |
| } |
| } |
| } |
| |
| /* |
| * parses the "JS" portion of the XML file |
| */ |
| private void parseJs( |
| final TreeMap<String, LiteralsCollection> nameToLitColl, |
| final HashMap<String, CodeCollection> nameToCodeColl, |
| Attributes attributes, Integer curFragment) { |
| curRelevantLitTypes.clear(); |
| curRelevantCodeTypes.clear(); |
| |
| if (attributes.getValue("idref") != null){ |
| |
| curStoryRef = attributes.getValue("idref"); |
| |
| if (curFragment != -1){ |
| //add this to the stories for this fragment |
| if (!GlobalInformation.fragmentToStories.containsKey(curFragment)){ |
| HashSet<String> insertSet = new HashSet<String>(); |
| insertSet.add(curStoryRef); |
| GlobalInformation.fragmentToStories.put(curFragment, insertSet); |
| } |
| else{ |
| GlobalInformation.fragmentToStories.get(curFragment).add(curStoryRef); |
| } |
| } |
| |
| for (String litType : nameToLitColl.keySet()){ |
| if (nameToLitColl.get(litType).storyToLocations.containsKey(curStoryRef)){ |
| curRelevantLitTypes.add(litType); |
| } |
| } |
| |
| specialCodeType = false; |
| for (String codeType : nameToCodeColl.keySet()){ |
| if (nameToCodeColl.get(codeType).stories.contains(curStoryRef)){ |
| curRelevantCodeTypes.add(codeType); |
| specialCodeType = true; |
| } |
| } |
| if (specialCodeType == false){ |
| |
| nameToCodeColl.get("allOther").stories.add(curStoryRef); |
| curRelevantCodeTypes.add("allOther"); |
| } |
| } |
| } |
| |
| /* |
| * parses the "origins" portion of the XML file |
| */ |
| private void parseOrigins( |
| final TreeMap<String, LiteralsCollection> nameToLitColl, |
| Attributes attributes) { |
| if ((curStoryLiteralType.compareTo("") != 0)&& |
| (attributes.getValue("lineNumber") != null)&& |
| (attributes.getValue("location") != null)){ |
| curLineNumber = attributes.getValue("lineNumber"); |
| curLocation = attributes.getValue("location"); |
| String curOrigin = curLocation + ": Line " + curLineNumber; |
| |
| if (!nameToLitColl.get(curStoryLiteralType).storyToLocations.containsKey(curStoryId)){ |
| HashSet<String> insertSet = new HashSet<String>(); |
| insertSet.add(curOrigin); |
| nameToLitColl.get(curStoryLiteralType).storyToLocations.put(curStoryId, insertSet); |
| } |
| else{ |
| nameToLitColl.get(curStoryLiteralType).storyToLocations.get(curStoryId).add(curOrigin); |
| } |
| } |
| } |
| |
| /* |
| * parses the split points |
| */ |
| private void parseSplitPoint(Attributes attributes){ |
| System.out.println("processing split point"); |
| if (attributes.getValue("id") != null){ |
| String curSplitPoint = attributes.getValue("id"); |
| System.out.println("\tcurSplitPoint is: " + curSplitPoint); |
| if (attributes.getValue("location") != null){ |
| String curSplitPointLocation = attributes.getValue("location"); |
| |
| curSplitPointLocation = curSplitPointLocation.replaceAll("\\(L.*",""); |
| |
| System.out.println("\tcurSplitPointLocation is: " + curSplitPointLocation); |
| GlobalInformation.splitPointToLocation.put(Integer.parseInt(curSplitPoint), curSplitPointLocation); |
| GlobalInformation.numSplitPoints++; |
| |
| System.out.println("adding split point and location: " + curSplitPoint + "-->" + curSplitPointLocation); |
| System.out.println("\t(Number of split points is now: " + GlobalInformation.numSplitPoints + ")"); |
| |
| } |
| } |
| } |
| |
| /* |
| * parses the "story" portion of the XML file |
| */ |
| private void parseStory(Attributes attributes) { |
| if (attributes.getValue("id") != null){ |
| curStoryId = attributes.getValue("id"); |
| if (attributes.getValue("literal") != null){ |
| curStoryLiteralType = attributes.getValue("literal"); |
| GlobalInformation.storiesToLitType.put(curStoryId, curStoryLiteralType); |
| |
| |
| if (!nameToLitColl.get(curStoryLiteralType).storyToLocations.containsKey(curStoryId)){ |
| HashSet<String> insertSet = new HashSet<String>(); |
| nameToLitColl.get(curStoryLiteralType).storyToLocations.put(curStoryId, insertSet); |
| } |
| |
| } |
| else{ |
| curStoryLiteralType = ""; |
| } |
| } |
| } |
| |
| /* |
| * parses the "correlations" portion of the XML file |
| */ |
| private void parseCorrelations( |
| final HashMap<String, CodeCollection> nameToCodeColl, |
| Attributes attributes) { |
| |
| if (attributes.getValue("idref") != null){ |
| |
| String corrClassOrMethod = attributes.getValue("idref"); |
| |
| String corrClass = attributes.getValue("idref"); |
| |
| if (corrClass.contains(":")){ |
| corrClass = corrClass.replaceAll(":.*", ""); |
| } |
| |
| if (GlobalInformation.classToPackage.containsKey(corrClass)){ //if we know about this class |
| |
| if (! GlobalInformation.storiesToCorrClassesAndMethods.containsKey(curStoryId)){ |
| HashSet<String> insertSet = new HashSet<String>(); |
| insertSet.add(corrClassOrMethod); |
| GlobalInformation.storiesToCorrClassesAndMethods.put(curStoryId, insertSet); |
| } |
| else{ |
| GlobalInformation.storiesToCorrClassesAndMethods.get(curStoryId).add(corrClassOrMethod); |
| } |
| |
| |
| if (! GlobalInformation.storiesToCorrClasses.containsKey(curStoryId)){ |
| HashSet<String> insertSet = new HashSet<String>(); |
| insertSet.add(corrClass); |
| GlobalInformation.storiesToCorrClasses.put(curStoryId, insertSet); |
| } |
| else{ |
| GlobalInformation.storiesToCorrClasses.get(curStoryId).add(corrClass); |
| } |
| |
| for (String codeType : nameToCodeColl.keySet()){ |
| if (nameToCodeColl.get(codeType).classes.contains(corrClass)){ |
| nameToCodeColl.get(codeType).stories.add(curStoryId); |
| } |
| } |
| } |
| } |
| } |
| |
| /* |
| * parses the "overrides" portion of the XML file |
| */ |
| private void parseOverrides( |
| final HashMap<String, CodeCollection> nameToCodeColl, |
| Attributes attributes) { |
| if (attributes.getValue("idref") != null){ |
| String overriddenClass = attributes.getValue("idref"); |
| |
| |
| //TODO(kprobst): fix this -- we either generalize to classes, or the numbers are messed up... |
| if (overriddenClass.contains(":")){ |
| overriddenClass = overriddenClass.replaceAll(":.*", ""); |
| } |
| |
| if (overriddenClass.compareTo("com.google.gwt.user.client.ui.UIObject") == 0){ |
| nameToCodeColl.get("widget").classes.add(curClassId); |
| } |
| else if (overriddenClass.contains("java.io.Serializable") || |
| overriddenClass.contains("IsSerializable")){ |
| nameToCodeColl.get("rpcUser").classes.add(curClassId); |
| } |
| else if (overriddenClass.contains("com.google.gwt.user.client.rpc.core.java")){ |
| nameToCodeColl.get("rpcGwt").classes.add(curClassId); |
| } |
| } |
| } |
| |
| /* |
| * parses the "class" portion of the XML file |
| */ |
| private void parseClass( |
| final HashMap<String, CodeCollection> nameToCodeColl, |
| Attributes attributes) { |
| if (attributes.getValue("id") != null){ |
| curClassId = attributes.getValue("id"); |
| |
| GlobalInformation.classToPackage.put(curClassId, curPackage); |
| |
| if (curPackage.startsWith("java")){ |
| nameToCodeColl.get("jre").classes.add(curClassId); |
| } |
| else if (curPackage.startsWith("com.google.gwt.lang")){ |
| nameToCodeColl.get("gwtLang").classes.add(curClassId); |
| } |
| if (curClassId.contains("_CustomFieldSerializer")){ |
| nameToCodeColl.get("rpcUser").classes.add(curClassId); |
| } |
| else if (curClassId.endsWith("_FieldSerializer") || |
| curClassId.endsWith("_Proxy") || |
| curClassId.endsWith("_TypeSerializer")){ |
| nameToCodeColl.get("rpcGen").classes.add(curClassId); |
| } |
| } |
| } |
| |
| /* |
| * parses the "depends on" portion of the XML file |
| */ |
| private void parseDependsOn(final HashMap<String, CodeCollection> nameToCodeColl, Attributes attributes) { |
| if (curFunctionId.compareTo("") == 0){ |
| if (attributes.getValue("idref") != null){ |
| String curDepClassId = attributes.getValue("idref"); |
| |
| if (curDepClassId.contains(":")){ |
| // strip everything after the :: (to get to class, even if it's a method) |
| curDepClassId = curDepClassId.replaceAll(":.*", ""); |
| } |
| |
| if (curDepClassId.contains(".")){ |
| if (! GlobalInformation.classToWhatItDependsOn.containsKey(curClassId)){ |
| HashSet<String> insertSet = new HashSet<String>(); |
| insertSet.add(curDepClassId); |
| GlobalInformation.classToWhatItDependsOn.put(curClassId, insertSet); |
| } |
| else{ |
| GlobalInformation.classToWhatItDependsOn.get(curClassId).add(curDepClassId); |
| } |
| } |
| } |
| } |
| } |
| }; |
| return handler; |
| } |
| |
| |
| |
| |
| |
| |
| |
| private static DefaultHandler parseXMLDocumentDependencies(final Map<String, ArrayList<String>> dependencies) { |
| |
| DefaultHandler handler = new DefaultHandler() { |
| |
| StringBuilder valueBuilder = new StringBuilder(); |
| // may want to create a class for this later |
| String curMethod; |
| |
| /** |
| * This method deals with the beginning of the XML element. |
| * It analyzes the XML node and adds its information to the relevant literal or code collection for later analysis. |
| * @see org.xml.sax.helpers.DefaultHandler#startElement(java.lang.String, java.lang.String, java.lang.String, org.xml.sax.Attributes) |
| */ |
| @Override |
| public void startElement(String nsUri, String strippedName, String tagName, Attributes attributes) { |
| |
| valueBuilder.delete(0,valueBuilder.length()); |
| |
| |
| if ((strippedName.compareTo("method") == 0)&&(attributes.getValue("name") != null)){ |
| curMethod = attributes.getValue("name"); |
| } |
| else if ((strippedName.compareTo("called") == 0)&&(attributes.getValue("by") != null)){ |
| String curDepMethod = attributes.getValue("by"); |
| if (!dependencies.containsKey(curMethod)){ |
| ArrayList<String> insertArray = new ArrayList<String>(); |
| insertArray.add(curDepMethod); |
| dependencies.put(curMethod, insertArray); |
| } |
| else{ |
| dependencies.get(curMethod).add(curDepMethod); |
| } |
| } |
| } |
| |
| }; |
| return handler; |
| } |
| |
| |
| |
| |
| |
| /* |
| * 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(); |
| } |
| |
| |
| } |
| |
| |
| /* |
| * generates all the HTML files |
| */ |
| private static void makeHTMLFiles( |
| final TreeMap<String, LiteralsCollection> nameToLitColl, |
| final HashMap<String, CodeCollection> nameToCodeColl) { |
| |
| try { |
| MakeTopLevelHtmlForPerm.makePackageClassesHtmls(); |
| MakeTopLevelHtmlForPerm.makeCodeTypeClassesHtmls(nameToCodeColl); |
| MakeTopLevelHtmlForPerm.makeLiteralsClassesTableHtmls(nameToLitColl); |
| MakeTopLevelHtmlForPerm.makeStringLiteralsClassesTableHtmls(nameToLitColl); |
| // MakeTopLevelHtmlForPerm.makeFragmentClassesHtmls(); |
| MakeTopLevelHtmlForPerm.makeSplitPointClassesHtmls(); |
| MakeTopLevelHtmlForPerm.makeDependenciesTableHtmls(); |
| |
| //make the shell last so we can display aggregate information here |
| MakeTopLevelHtmlForPerm.makeHTMLShell(nameToCodeColl, nameToLitColl); |
| |
| } catch (IOException e) { |
| throw new RuntimeException("Cannot open file. ", e); |
| } |
| } |
| |
| |
| /* |
| * assigns code to "all other code" if none of the special categories apply |
| */ |
| private static void updateAllOtherCodeType(final HashMap<String, CodeCollection> nameToCodeColl){ |
| //all classes not in any of the other categories |
| for (String className : GlobalInformation.classToPackage.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); |
| } |
| } |
| } |
| |
| |
| /* |
| * unescape the JS snippets - in the XML file they are XML encoded for correct display, but this |
| * will mess up the byte counts |
| */ |
| public static String unEscapeXml(String escaped) { |
| String unescaped = escaped.replaceAll("&","\\&"); |
| unescaped = unescaped.replaceAll("<","\\<"); |
| unescaped = unescaped.replaceAll(">","\\>"); |
| unescaped = unescaped.replaceAll(""","\\\""); |
| //escaped = escaped.replaceAll("\\n", ""); |
| unescaped = unescaped.replaceAll("'","\\'"); |
| return unescaped; |
| } |
| |
| |
| |
| |
| } |
| |
| |
| |
| |
| |
