Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* 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.dev.cfg;
import com.google.gwt.core.ext.Linker;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.linker.LinkerOrder;
import com.google.gwt.core.ext.linker.LinkerOrder.Order;
import com.google.gwt.core.ext.typeinfo.TypeOracle;
import com.google.gwt.dev.CompilerContext;
import com.google.gwt.dev.javac.CompilationProblemReporter;
import com.google.gwt.dev.javac.CompilationState;
import com.google.gwt.dev.javac.CompilationStateBuilder;
import com.google.gwt.dev.resource.Resource;
import com.google.gwt.dev.resource.ResourceOracle;
import com.google.gwt.dev.resource.impl.DefaultFilters;
import com.google.gwt.dev.resource.impl.PathPrefix;
import com.google.gwt.dev.resource.impl.PathPrefixSet;
import com.google.gwt.dev.resource.impl.ResourceFilter;
import com.google.gwt.dev.resource.impl.ResourceOracleImpl;
import com.google.gwt.dev.util.Empty;
import com.google.gwt.dev.util.Util;
import com.google.gwt.dev.util.log.speedtracer.CompilerEventType;
import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger;
import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger.Event;
import com.google.gwt.thirdparty.guava.common.base.Preconditions;
import com.google.gwt.thirdparty.guava.common.collect.Lists;
import java.io.File;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
* Represents a module specification. In principle, this could be built without
* XML for unit tests.
*/
public class ModuleDef {
/**
* Marks a module in a way that can be used to calculate the effective bounds of a library module
* in a module tree.
*/
public enum ModuleType {
/**
* A module that acts as just a bundle of source code to be included in a referencing library.
* The contained code may form circular references with other source within the contiguous chunk
* of modules made up of a library and it's subtree of filesets. As a result a fileset can not
* be compiled on it's own and must be compiled as part of a library.
*/
FILESET,
/**
* The default type of module. Libraries should be independently compilable and are expected to
* explicitly declare all of their immediate dependencies and include paths and none of their
* contained source should be part of a circular reference with any source outside the effective
* bounds of the library.
*/
LIBRARY
}
/**
* When walking a module tree of mixed library and fileset modules, attributes are accumulated and
* stored. But when compiling separately, some attributes should only be collected from the
* effective target module. AttributeSource is used to classify these "in target module" and "out
* of target module" times.
*/
private enum AttributeSource {
EXTERNAL_LIBRARY, TARGET_LIBRARY
}
private static final ResourceFilter NON_JAVA_RESOURCES = new ResourceFilter() {
@Override
public boolean allows(String path) {
return !path.endsWith(".java") && !path.endsWith(".class");
}
};
private static final Comparator> REV_NAME_CMP =
new Comparator>() {
@Override
public int compare(Map.Entry entry1, Map.Entry entry2) {
String key1 = entry1.getKey();
String key2 = entry2.getKey();
// intentionally reversed
return key2.compareTo(key1);
}
};
public static boolean isValidModuleName(String moduleName) {
// Check for an empty string between two periods.
if (moduleName.contains("..")) {
return false;
}
// Insure the package name components are a valid Java ident.
String[] parts = moduleName.split("\\.");
for (int i = 0; i < parts.length - 1; i++) {
String part = parts[i];
if (!Util.isValidJavaIdent(part)) {
return false;
}
}
return true;
}
private final Set activeLinkers = new LinkedHashSet();
private String activePrimaryLinker;
/**
* A set of URLs for .gwtar files found on the classpath that correspond
* to .gwt.xml files loaded as a part of this module's nested load.
*
* @see com.google.gwt.dev.CompileModule
*/
private final List archiveURLs = new ArrayList();
private boolean collapseAllProperties;
private final DefaultFilters defaultFilters;
private final List entryPointTypeNames = new ArrayList();
private final Set gwtXmlFiles = new HashSet();
private final Set inheritedModules = new HashSet();
/**
* All resources found on the public path, specified by directives in
* modules (or the implicit ./public directory). Marked 'lazy' because it does not
* start searching for resources until a query is made.
*/
private ResourceOracleImpl lazyPublicOracle;
/**
* A subset of lazySourceOracle, contains files other than .java and .class files.
*/
private ResourceOracleImpl lazyResourcesOracle;
/**
* Contains all files from the source path, specified by and
* directives in modules (or the implicit ./client directory).
*/
private ResourceOracleImpl lazySourceOracle;
private final Map> linkerTypesByName =
new LinkedHashMap>();
private final long moduleDefCreationTime = System.currentTimeMillis();
/**
* Whether the module tree is being considered to be one contiguous compilable whole as opposed to
* a tree of independently compilable library modules.
*/
private final boolean monolithic;
private final String name;
private final ResourceLoader resources;
/**
* Must use a separate field to track override, because setNameOverride() will
* get called every time a module is inherited, but only the last one matters.
*/
private String nameOverride;
/**
* Used to keep track of the current category of attribute source. When the attribute source is
* TARGET_LIBRARY all attributes are accumulated but when it is EXTERNAL_LIBRARY there are some
* attributes that are not collected.
*/
private Deque currentAttributeSource = Lists.newLinkedList();
private boolean needsRefresh;
private final Properties properties = new Properties();
private PathPrefixSet publicPrefixSet = new PathPrefixSet();
private final Rules rules = new Rules();
private final Scripts scripts = new Scripts();
private final Map servletClassNamesByPath = new HashMap();
private PathPrefixSet sourcePrefixSet = new PathPrefixSet();
private final Styles styles = new Styles();
public ModuleDef(String name) {
this(name, ResourceLoaders.forClassLoader(Thread.currentThread()));
}
public ModuleDef(String name, ResourceLoader resources) {
this(name, resources, true);
}
public ModuleDef(String name, ResourceLoader resources, boolean monolithic) {
this.name = name;
this.resources = resources;
this.monolithic = monolithic;
defaultFilters = new DefaultFilters();
}
public synchronized void addEntryPointTypeName(String typeName) {
if (!attributeIsForTargetLibrary()) {
return;
}
entryPointTypeNames.add(typeName);
}
public void addGwtXmlFile(File xmlFile) {
gwtXmlFiles.add(xmlFile);
}
public void addLinker(String name) {
Class clazz = getLinker(name);
assert clazz != null;
LinkerOrder order = clazz.getAnnotation(LinkerOrder.class);
if (order.value() == Order.PRIMARY) {
if (activePrimaryLinker != null) {
activeLinkers.remove(activePrimaryLinker);
}
activePrimaryLinker = name;
}
activeLinkers.add(name);
}
public synchronized void addPublicPackage(String publicPackage, String[] includeList,
String[] excludeList, String[] skipList, boolean defaultExcludes, boolean caseSensitive) {
if (lazyPublicOracle != null) {
throw new IllegalStateException("Already normalized");
}
if (!attributeIsForTargetLibrary()) {
return;
}
publicPrefixSet.add(new PathPrefix(publicPackage, defaultFilters.customResourceFilter(
includeList, excludeList, skipList, defaultExcludes, caseSensitive), true, excludeList));
}
public void addRule(Rule rule) {
if (!attributeIsForTargetLibrary()) {
return;
}
getRules().prepend(rule);
}
public void addSourcePackage(String sourcePackage, String[] includeList, String[] excludeList,
String[] skipList, boolean defaultExcludes, boolean caseSensitive) {
addSourcePackageImpl(sourcePackage, includeList, excludeList, skipList, defaultExcludes,
caseSensitive, false);
}
public void addSourcePackageImpl(String sourcePackage, String[] includeList,
String[] excludeList, String[] skipList, boolean defaultExcludes, boolean caseSensitive,
boolean isSuperSource) {
if (lazySourceOracle != null) {
throw new IllegalStateException("Already normalized");
}
if (!attributeIsForTargetLibrary()) {
return;
}
PathPrefix pathPrefix =
new PathPrefix(sourcePackage, defaultFilters.customJavaFilter(includeList, excludeList,
skipList, defaultExcludes, caseSensitive), isSuperSource, excludeList);
sourcePrefixSet.add(pathPrefix);
}
public void addSuperSourcePackage(String superSourcePackage, String[] includeList,
String[] excludeList, String[] skipList, boolean defaultExcludes, boolean caseSensitive) {
addSourcePackageImpl(superSourcePackage, includeList, excludeList, skipList, defaultExcludes,
caseSensitive, true);
}
/**
* Free up memory no longer needed in later compile stages. After calling this
* method, the ResourceOracle will be empty and unusable. Calling
* {@link #refresh()} will restore them.
*/
public synchronized void clear() {
if (lazySourceOracle != null) {
lazySourceOracle.clear();
}
rules.dispose();
}
public void clearEntryPoints() {
entryPointTypeNames.clear();
}
/**
* Associate a Linker class with a symbolic name. If the name had been
* previously assigned, this method will redefine the name. If the redefined
* linker had been previously added to the set of active linkers, the old
* active linker will be replaced with the new linker.
*/
public void defineLinker(TreeLogger logger, String name, Class linker)
throws UnableToCompleteException {
Class old = getLinker(name);
if (old != null) {
// Redefining an existing name
if (activePrimaryLinker.equals(name)) {
// Make sure the new one is also a primary linker
if (!linker.getAnnotation(LinkerOrder.class).value().equals(Order.PRIMARY)) {
logger.log(TreeLogger.ERROR, "Redefining primary linker " + name
+ " with non-primary implementation " + linker.getName());
throw new UnableToCompleteException();
}
} else if (activeLinkers.contains(name)) {
// Make sure it's a not a primary linker
if (linker.getAnnotation(LinkerOrder.class).value().equals(Order.PRIMARY)) {
logger.log(TreeLogger.ERROR, "Redefining non-primary linker " + name
+ " with primary implementation " + linker.getName());
throw new UnableToCompleteException();
}
}
}
linkerTypesByName.put(name, linker);
}
/**
* Called as module tree parsing enters and exits individual module file of various types and so
* provides the ModuleDef with an opportunity to keep track of what context it is currently
* operating.
*
* At the moment the ModuleDef uses it's monolithic property in combination with the entering
* modules ModuleType to updates its idea of attribute source.
*/
public void enterModule(ModuleType moduleType) {
if (monolithic) {
// When you're monolithic the module tree is all effectively one giant library.
currentAttributeSource.push(AttributeSource.TARGET_LIBRARY);
return;
}
// When compiling separately it's not legal to have a fileset module at the root.
Preconditions.checkArgument(
!(currentAttributeSource.isEmpty() && moduleType == ModuleType.FILESET));
// The compilation target always starts at the root of the graph so if there is a library type
// module at the root of the graph.
if (currentAttributeSource.isEmpty() && moduleType == ModuleType.LIBRARY) {
// Then any attributes you see are your own.
currentAttributeSource.push(AttributeSource.TARGET_LIBRARY);
return;
}
// If at the moment any attributes you see are your own.
if (currentAttributeSource.peek() == AttributeSource.TARGET_LIBRARY) {
// And you enter a fileset module
if (moduleType == ModuleType.FILESET) {
// Then any attributes you see are still your own.
currentAttributeSource.push(AttributeSource.TARGET_LIBRARY);
} else {
// But if you enter a library module then any attributes you see are external.
currentAttributeSource.push(AttributeSource.EXTERNAL_LIBRARY);
}
} else if (currentAttributeSource.peek() == AttributeSource.EXTERNAL_LIBRARY) {
// If your current attribute source is an external library then regardless of whether you
// enter another fileset or library your attribute source is still external.
currentAttributeSource.push(AttributeSource.EXTERNAL_LIBRARY);
}
}
public void exitModule() {
currentAttributeSource.pop();
}
public synchronized Resource findPublicFile(String partialPath) {
doRefresh();
return lazyPublicOracle.getResourceMap().get(partialPath);
}
public synchronized String findServletForPath(String actual) {
// Walk in backwards sorted order to find the longest path match first.
Set> entrySet = servletClassNamesByPath.entrySet();
Entry[] entries = Util.toArray(Entry.class, entrySet);
Arrays.sort(entries, REV_NAME_CMP);
for (int i = 0, n = entries.length; i < n; ++i) {
String mapping = entries[i].getKey();
/*
* Ensure that URLs that match the servlet mapping, including those that
* have additional path_info, get routed to the correct servlet.
*
* See "Inside Servlets", Second Edition, pg. 208
*/
if (actual.equals(mapping) || actual.startsWith(mapping + "/")) {
return entries[i].getValue();
}
}
return null;
}
/**
* Returns the Resource for a source file if it is found; null
* otherwise.
*
* @param partialPath the partial path of the source file
* @return the resource for the requested source file
*/
public synchronized Resource findSourceFile(String partialPath) {
doRefresh();
return lazySourceOracle.getResourceMap().get(partialPath);
}
public Set getActiveLinkerNames() {
return new LinkedHashSet(activeLinkers);
}
public Set> getActiveLinkers() {
Set> toReturn = new LinkedHashSet>();
for (String linker : activeLinkers) {
assert linkerTypesByName.containsKey(linker) : linker;
toReturn.add(linkerTypesByName.get(linker));
}
return toReturn;
}
public Class getActivePrimaryLinker() {
assert linkerTypesByName.containsKey(activePrimaryLinker) : activePrimaryLinker;
return linkerTypesByName.get(activePrimaryLinker);
}
/**
* Returns URLs to fetch archives of precompiled compilation units.
*
* @see com.google.gwt.dev.CompileModule
*/
public Collection getAllCompilationUnitArchiveURLs() {
return Collections.unmodifiableCollection(archiveURLs);
}
public String[] getAllPublicFiles() {
doRefresh();
return lazyPublicOracle.getPathNames().toArray(Empty.STRINGS);
}
/**
* Strictly for statistics gathering. There is no guarantee that the source
* oracle has been initialized.
*/
public String[] getAllSourceFiles() {
doRefresh();
return lazySourceOracle.getPathNames().toArray(Empty.STRINGS);
}
/**
* Returns the physical name for the module by which it can be found in the
* classpath.
*/
public String getCanonicalName() {
return name;
}
/**
* Provided for Designer compatibility. Do not use.
*/
@Deprecated
public CompilationState getCompilationState(TreeLogger logger)
throws UnableToCompleteException {
CompilerContext emptyCompilerContext = new CompilerContext.Builder().build();
return getCompilationState(logger, emptyCompilerContext);
}
public CompilationState getCompilationState(TreeLogger logger, CompilerContext compilerContext)
throws UnableToCompleteException {
doRefresh();
CompilationState compilationState =
CompilationStateBuilder.buildFrom(logger, compilerContext, lazySourceOracle.getResources());
checkForSeedTypes(logger, compilationState);
return compilationState;
}
public synchronized String[] getEntryPointTypeNames() {
final int n = entryPointTypeNames.size();
return entryPointTypeNames.toArray(new String[n]);
}
public synchronized String getFunctionName() {
return getName().replace('.', '_');
}
public Class getLinker(String name) {
return linkerTypesByName.get(name);
}
public Map> getLinkers() {
return linkerTypesByName;
}
public synchronized String getName() {
return nameOverride != null ? nameOverride : name;
}
/**
* The properties that have been defined.
*/
public synchronized Properties getProperties() {
return properties;
}
public synchronized ResourceOracle getResourcesOracle() {
if (lazyResourcesOracle == null) {
lazyResourcesOracle = new ResourceOracleImpl(TreeLogger.NULL, resources);
PathPrefixSet pathPrefixes = lazySourceOracle.getPathPrefixes();
PathPrefixSet newPathPrefixes = new PathPrefixSet();
for (PathPrefix pathPrefix : pathPrefixes.values()) {
newPathPrefixes.add(new PathPrefix(pathPrefix.getPrefix(), NON_JAVA_RESOURCES, pathPrefix
.shouldReroot()));
}
lazyResourcesOracle.setPathPrefixes(newPathPrefixes);
ResourceOracleImpl.refresh(TreeLogger.NULL, lazyResourcesOracle);
} else {
doRefresh();
}
return lazyResourcesOracle;
}
/**
* Gets a reference to the internal rules for this module def.
*/
public synchronized Rules getRules() {
return rules;
}
/**
* Gets a reference to the internal scripts list for this module def.
*/
public Scripts getScripts() {
return scripts;
}
public synchronized String[] getServletPaths() {
return servletClassNamesByPath.keySet().toArray(Empty.STRINGS);
}
/**
* Gets a reference to the internal styles list for this module def.
*/
public Styles getStyles() {
return styles;
}
public boolean isGwtXmlFileStale() {
return lastModified() > moduleDefCreationTime;
}
public boolean isInherited(String moduleName) {
return inheritedModules.contains(moduleName);
}
public long lastModified() {
long lastModified = 0;
for (File xmlFile : gwtXmlFiles) {
if (xmlFile.exists()) {
lastModified = Math.max(lastModified, xmlFile.lastModified());
}
}
return lastModified > 0 ? lastModified : moduleDefCreationTime;
}
/**
* For convenience in unit tests, servlets can be automatically loaded and
* mapped in the embedded web server. If a servlet is already mapped to the
* specified path, it is replaced.
*
* @param path the url path at which the servlet resides
* @param servletClassName the name of the servlet to publish
*/
public synchronized void mapServlet(String path, String servletClassName) {
servletClassNamesByPath.put(path, servletClassName);
}
public synchronized void refresh() {
needsRefresh = true;
}
/**
* Mainly for testing and decreasing compile times.
*/
public void setCollapseAllProperties(boolean collapse) {
collapseAllProperties = collapse;
}
/**
* Override the module's apparent name. Setting this value to
* null will disable the name override.
*/
public synchronized void setNameOverride(String nameOverride) {
this.nameOverride = nameOverride;
}
void addCompilationUnitArchiveURL(URL url) {
archiveURLs.add(url);
}
void addInteritedModule(String moduleName) {
inheritedModules.add(moduleName);
}
/**
* The final method to call when everything is setup. Before calling this
* method, several of the getter methods may not be called. After calling this
* method, the add methods may not be called.
*
* @param logger Logs the activity.
*/
synchronized void normalize(TreeLogger logger) {
Event moduleDefNormalize =
SpeedTracerLogger.start(CompilerEventType.MODULE_DEF, "phase", "normalize");
// Normalize property providers.
//
for (Property current : getProperties()) {
if (current instanceof BindingProperty) {
BindingProperty prop = (BindingProperty) current;
if (collapseAllProperties) {
prop.addCollapsedValues("*");
}
prop.normalizeCollapsedValues();
/*
* Create a default property provider for any properties with more than
* one possible value and no existing provider.
*/
if (prop.getProvider() == null && prop.getConstrainedValue() == null) {
String src = "{";
src += "return __gwt_getMetaProperty(\"";
src += prop.getName();
src += "\"); }";
prop.setProvider(new PropertyProvider(src));
}
}
}
// Create the public path.
TreeLogger branch = Messages.PUBLIC_PATH_LOCATIONS.branch(logger, null);
lazyPublicOracle = new ResourceOracleImpl(branch, resources);
lazyPublicOracle.setPathPrefixes(publicPrefixSet);
// Create the source path.
branch = Messages.SOURCE_PATH_LOCATIONS.branch(logger, null);
lazySourceOracle = new ResourceOracleImpl(branch, resources);
lazySourceOracle.setPathPrefixes(sourcePrefixSet);
needsRefresh = true;
moduleDefNormalize.end();
}
private void checkForSeedTypes(TreeLogger logger, CompilationState compilationState)
throws UnableToCompleteException {
// Sanity check the seed types and don't even start it they're missing.
boolean seedTypesMissing = false;
TypeOracle typeOracle = compilationState.getTypeOracle();
if (typeOracle.findType("java.lang.Object") == null) {
CompilationProblemReporter.logMissingTypeErrorWithHints(logger, "java.lang.Object",
compilationState);
seedTypesMissing = true;
} else {
TreeLogger branch = logger.branch(TreeLogger.TRACE, "Finding entry point classes", null);
String[] typeNames = getEntryPointTypeNames();
for (int i = 0; i < typeNames.length; i++) {
String typeName = typeNames[i];
if (typeOracle.findType(typeName) == null) {
CompilationProblemReporter.logMissingTypeErrorWithHints(branch, typeName,
compilationState);
seedTypesMissing = true;
}
}
}
if (seedTypesMissing) {
throw new UnableToCompleteException();
}
}
private synchronized void doRefresh() {
if (!needsRefresh) {
return;
}
Event moduleDefEvent =
SpeedTracerLogger.start(CompilerEventType.MODULE_DEF, "phase", "refresh", "module",
getName());
// Refresh resource oracles.
if (lazyResourcesOracle == null) {
ResourceOracleImpl.refresh(TreeLogger.NULL, lazyPublicOracle, lazySourceOracle);
} else {
ResourceOracleImpl.refresh(TreeLogger.NULL, lazyPublicOracle, lazySourceOracle,
lazyResourcesOracle);
}
moduleDefEvent.end();
needsRefresh = false;
}
private boolean attributeIsForTargetLibrary() {
return currentAttributeSource.isEmpty()
|| currentAttributeSource.peek() == AttributeSource.TARGET_LIBRARY;
}
}
