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 2007 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.jjs;
import java.util.ArrayList;
import java.util.List;
/**
* Indicates the compiler encountered an unexpected and unsupported state of
* operation.
*/
public class InternalCompilerException extends RuntimeException {
/**
* Information regarding a node that was being processed when an
* InternalCompilerException was thrown.
*/
public static final class NodeInfo {
static void preload() {
// Initialize this class on static invocation.
}
private final String className;
private final String description;
private final SourceInfo sourceInfo;
NodeInfo(String className, String description, SourceInfo sourceInfo) {
this.className = className;
this.description = description;
this.sourceInfo = sourceInfo;
}
/**
* Returns the name of the Java class of the node.
*/
public String getClassName() {
return className;
}
/**
* Returns a text description of the node; typically toString().
*/
public String getDescription() {
return description;
}
/**
* Returns the node's source info, if available; otherwise {@code null}.
*/
public SourceInfo getSourceInfo() {
return sourceInfo;
}
}
/**
* Tracks if there's a pending addNode() to avoid recursion sickness.
*/
private static final ThreadLocal pendingICE =
new ThreadLocal();
/**
* Force this class to be preloaded. If we don't preload this class, we can
* get into bad behavior if we later try to load this class under out of
* memory or out of stack conditions.
*/
public static void preload() {
// Initialize this class on static invocation.
NodeInfo.preload();
pendingICE.set(pendingICE.get());
}
private final List nodeTrace = new ArrayList();
/**
* Constructs a new exception with the specified node, message, and cause.
*/
public InternalCompilerException(HasSourceInfo node, String message, Throwable cause) {
this(message, cause);
addNode(node);
}
/**
* Constructs a new exception with the specified message.
*/
public InternalCompilerException(String message) {
super(message);
}
/**
* Constructs a new exception with the specified message and cause.
*/
public InternalCompilerException(String message, Throwable cause) {
super(message, cause);
}
/**
* Adds a node to the end of the node trace. This is similar to how a stack
* trace works.
*/
public void addNode(HasSourceInfo node) {
InternalCompilerException other = pendingICE.get();
if (other != null) {
// Avoiding recursion sickness: Yet Another ICE must have occurred while
// generating info for a prior ICE. Just bail!
return;
}
String className = null;
String description = null;
SourceInfo sourceInfo = null;
try {
pendingICE.set(this);
className = node.getClass().getName();
sourceInfo = node.getSourceInfo();
description = node.toString();
} catch (Throwable e) {
// ignore any exceptions
if (description == null) {
description = "";
}
} finally {
pendingICE.set(null);
}
addNode(className, description, sourceInfo);
}
/**
* Adds information about a a node to the end of the node trace. This is
* similar to how a stack trace works.
*/
public void addNode(String className, String description, SourceInfo sourceInfo) {
nodeTrace.add(new NodeInfo(className, description, sourceInfo));
}
/**
* Returns a list of nodes that were being processed when this exception was
* thrown. The list reflects the parent-child relationships of the AST and is
* is in order from children to parents. The first element of the returned
* list is the node that was most specifically being visited when the
* exception was thrown.
*/
public List getNodeTrace() {
return nodeTrace;
}
}
