/*
* Copyright 2009 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.core.ext.soyc.impl;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.soyc.ClassMember;
import com.google.gwt.core.ext.soyc.FunctionMember;
import com.google.gwt.core.ext.soyc.Member;
import com.google.gwt.core.ext.soyc.Range;
import com.google.gwt.core.ext.soyc.Story;
import com.google.gwt.core.ext.soyc.Story.Origin;
import com.google.gwt.dev.jjs.Correlation;
import com.google.gwt.dev.jjs.SourceInfo;
import com.google.gwt.dev.jjs.Correlation.Axis;
import com.google.gwt.dev.jjs.ast.JDeclaredType;
import com.google.gwt.dev.jjs.ast.JField;
import com.google.gwt.dev.jjs.ast.JMethod;
import com.google.gwt.dev.js.ast.JsFunction;
import com.google.gwt.dev.util.Util;
import com.google.gwt.util.tools.Utility;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.Stack;
import java.util.TreeSet;
import java.util.zip.GZIPOutputStream;
/**
* Records {@link Story}s to a file for Compile Reports.
*/
public class StoryRecorder {
/**
* Associates a SourceInfo with a Range.
*/
private static class RangeInfo {
public final SourceInfo info;
public final Range range;
public RangeInfo(Range range, SourceInfo info) {
assert range != null;
assert info != null;
this.range = range;
this.info = info;
}
}
private static final int MAX_STRING_BUILDER_SIZE = 65536;
/**
* Used to record dependencies of a program.
*/
public static void recordStories(TreeLogger logger, OutputStream out,
List<Map<Range, SourceInfo>> sourceInfoMaps, String[] js) {
new StoryRecorder().recordStoriesImpl(logger, out, sourceInfoMaps, js);
}
private StringBuilder builder;
private int curHighestFragment = 0;
private OutputStream gzipStream;
private String[] js;
/**
* Used by {@link #popAndRecord(Stack)} to determine start and end ranges.
*/
private int lastEnd = 0;
/**
* This is a class field for convenience, but it should be deleted at the end
* of the constructor.
*/
private transient Map<Correlation, Member> membersByCorrelation = new IdentityHashMap<Correlation, Member>();
/**
* This is a class field for convenience, but it should be deleted at the end
* of the constructor.
*/
private transient Map<SourceInfo, StoryImpl> storyCache = new IdentityHashMap<SourceInfo, StoryImpl>();
private Map<Story, Integer> storyIds = new HashMap<Story, Integer>();
private StoryRecorder() {
}
protected void recordStoriesImpl(TreeLogger logger, OutputStream out,
List<Map<Range, SourceInfo>> sourceInfoMaps, String[] js) {
logger = logger.branch(TreeLogger.INFO, "Creating Stories file for the compile report");
this.js = js;
try {
builder = new StringBuilder(MAX_STRING_BUILDER_SIZE * 2);
gzipStream = new GZIPOutputStream(out);
/*
* Don't retain beyond the constructor to avoid lingering references to
* AST nodes.
*/
MemberFactory memberFactory = new MemberFactory();
// Record what we've seen so far
TreeSet<ClassMember> classesMutable = new TreeSet<ClassMember>(
Member.SOURCE_NAME_COMPARATOR);
TreeSet<FunctionMember> functionsMutable = new TreeSet<FunctionMember>(
Member.SOURCE_NAME_COMPARATOR);
Set<SourceInfo> sourceInfoSeen = new HashSet<SourceInfo>();
builder.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<soyc>\n<stories>\n");
int fragment = 0;
for (Map<Range, SourceInfo> sourceInfoMap : sourceInfoMaps) {
lastEnd = 0;
analyzeFragment(memberFactory, classesMutable, functionsMutable,
sourceInfoMap, sourceInfoSeen, fragment++);
// Flush output to improve memory locality
flushOutput();
}
builder.append("</stories>\n</soyc>\n");
/*
* Clear the member fields that we don't need anymore to allow GC of the
* SourceInfo objects
*/
membersByCorrelation = null;
storyCache = null;
Util.writeUtf8(builder, gzipStream);
Utility.close(gzipStream);
logger.log(TreeLogger.INFO, "Done");
} catch (Throwable e) {
logger.log(TreeLogger.ERROR, "Could not write dependency file.", e);
}
}
private void analyzeFragment(MemberFactory memberFactory,
TreeSet<ClassMember> classesMutable,
TreeSet<FunctionMember> functionsMutable,
Map<Range, SourceInfo> sourceInfoMap, Set<SourceInfo> sourceInfoSeen,
int fragment) throws IOException {
/*
* We want to iterate over the Ranges so that enclosing Ranges come before
* their enclosed Ranges...
*/
Range[] dependencyOrder = sourceInfoMap.keySet().toArray(
new Range[sourceInfoMap.size()]);
Arrays.sort(dependencyOrder, Range.DEPENDENCY_ORDER_COMPARATOR);
Stack<RangeInfo> dependencyScope = new Stack<RangeInfo>();
for (Range range : dependencyOrder) {
SourceInfo info = sourceInfoMap.get(range);
assert info != null;
// Infer dependency information
if (!dependencyScope.isEmpty()) {
/*
* Pop frames until we get back to a container, using this as a chance
* to build up our list of non-overlapping Ranges to report back to the
* user.
*/
while (!dependencyScope.peek().range.contains(range)) {
popAndRecord(dependencyScope, fragment);
}
}
// Possibly create and record Members
if (!sourceInfoSeen.contains(info)) {
sourceInfoSeen.add(info);
for (Correlation c : info.getPrimaryCorrelationsArray()) {
if (c == null) {
continue;
}
if (membersByCorrelation.containsKey(c)) {
continue;
}
switch (c.getAxis()) {
case CLASS: {
JDeclaredType type = c.getType();
StandardClassMember member = memberFactory.get(type);
membersByCorrelation.put(c, member);
classesMutable.add(member);
break;
}
case FIELD: {
JField field = c.getField();
JDeclaredType type = c.getType();
StandardFieldMember member = memberFactory.get(field);
memberFactory.get(type).addField(member);
membersByCorrelation.put(c, member);
break;
}
case FUNCTION: {
JsFunction function = c.getFunction();
StandardFunctionMember member = memberFactory.get(function);
membersByCorrelation.put(c, member);
functionsMutable.add(member);
break;
}
case METHOD: {
JMethod method = c.getMethod();
JDeclaredType type = c.getType();
StandardMethodMember member = memberFactory.get(method);
memberFactory.get(type).addMethod(member);
membersByCorrelation.put(c, member);
break;
}
}
}
}
dependencyScope.push(new RangeInfo(range, info));
}
// Unwind the rest of the stack to finish out the ranges
while (!dependencyScope.isEmpty()) {
popAndRecord(dependencyScope, fragment);
}
/*
* Because the first Range corresponds to the SourceInfo of the whole
* program, we'll know that we got all of the data if the ends match up. If
* this assert passes, we know that we've correctly generated a sequence of
* non-overlapping Ranges that encompass the whole program.
*/
assert dependencyOrder[0].getEnd() == lastEnd;
}
private void emitStory(StoryImpl story, Range range) throws IOException {
int storyNum;
if (storyIds.containsKey(story)) {
storyNum = storyIds.get(story);
} else {
storyNum = storyIds.size();
storyIds.put(story, storyNum);
}
builder.append("<story id=\"story");
builder.append(storyNum);
if (story.getLiteralTypeName() != null) {
builder.append("\" literal=\"");
builder.append(story.getLiteralTypeName());
}
builder.append("\">\n");
Set<Origin> origins = story.getSourceOrigin();
if (origins.size() > 0) {
builder.append("<origins>\n");
for (Origin origin : origins) {
builder.append("<origin lineNumber=\"");
builder.append(origin.getLineNumber());
builder.append("\" location=\"");
builder.append(origin.getLocation());
builder.append("\"/>\n");
flushOutput();
}
builder.append("</origins>\n");
}
Set<Member> correlations = story.getMembers();
if (correlations.size() > 0) {
builder.append("<correlations>\n");
for (Member correlation : correlations) {
builder.append("<by idref=\"");
builder.append(correlation.getSourceName());
builder.append("\"/>\n");
flushOutput();
}
builder.append("</correlations>\n");
}
builder.append("<js fragment=\"");
builder.append(curHighestFragment);
builder.append("\"/>\n<storyref idref=\"story");
builder.append(storyNum);
int start = range.getStart();
int end = range.getEnd();
String jsCode = js[curHighestFragment];
if ((start == end) || ((end == start + 1) && jsCode.charAt(start) == '\n')) {
builder.append("\"/>\n</story>\n");
} else {
builder.append("\">");
SizeMapRecorder.escapeXml(jsCode, start, end, false, builder);
builder.append("</storyref>\n</story>\n");
}
}
private void flushOutput() throws IOException {
// Flush output to improve memory locality
if (builder.length() > MAX_STRING_BUILDER_SIZE) {
Util.writeUtf8(builder, gzipStream);
builder.setLength(0);
}
}
/**
* Remove an element from the RangeInfo stack and stare a new StoryImpl with
* the right length, possibly sub-dividing the super-enclosing Range in the
* process.
*/
private void popAndRecord(Stack<RangeInfo> dependencyScope, int fragment)
throws IOException {
RangeInfo rangeInfo = dependencyScope.pop();
Range toStore = rangeInfo.range;
/*
* Make a new Range for the gap between the popped Range and whatever we
* last stored.
*/
if (lastEnd < toStore.getStart()) {
Range newRange = new Range(lastEnd, toStore.getStart());
assert !dependencyScope.isEmpty();
SourceInfo gapInfo = dependencyScope.peek().info;
recordStory(gapInfo, fragment, newRange.length(), newRange);
lastEnd += newRange.length();
}
/*
* Store as much of the current Range as we haven't previously stored. The
* Max.max() is there to take care of the tail end of Ranges that have had a
* sub-range previously stored.
*/
if (lastEnd < toStore.getEnd()) {
Range newRange = new Range(Math.max(lastEnd, toStore.getStart()),
toStore.getEnd());
recordStory(rangeInfo.info, fragment, newRange.length(), newRange);
lastEnd += newRange.length();
}
}
private void recordStory(SourceInfo info, int fragment, int length,
Range range) throws IOException {
assert info != null;
assert storyCache != null;
if (fragment > curHighestFragment) {
curHighestFragment = fragment;
}
StoryImpl theStory;
if (!storyCache.containsKey(info)) {
SortedSet<Member> members = new TreeSet<Member>(
Member.TYPE_AND_SOURCE_NAME_COMPARATOR);
Set<Origin> origins = new HashSet<Origin>();
for (Correlation c : info.getAllCorrelations()) {
Member m = membersByCorrelation.get(c);
if (m != null) {
members.add(m);
}
if (c.getAxis() == Axis.ORIGIN) {
origins.add(new OriginImpl(c.getOrigin()));
}
}
String literalType = null;
Correlation literalCorrelation = info.getPrimaryCorrelation(Axis.LITERAL);
if (literalCorrelation != null) {
literalType = literalCorrelation.getLiteral().getDescription();
}
theStory = new StoryImpl(storyCache.size(), members, origins,
literalType, fragment, length);
storyCache.put(info, theStory);
} else {
// Use a copy-constructed instance
theStory = new StoryImpl(storyCache.get(info), length);
}
emitStory(theStory, range);
}
}