@Override
public Component getListCellRendererComponent(
JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
// ### We should indicate the current thread independently of the
// ### selection, e.g., with an icon, because the user may change
// ### the selection graphically without affecting the current
// ### thread.
super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
if (value == null) {
this.setText("<unavailable>");
} else {
StackFrame frame = (StackFrame) value;
Location loc = frame.location();
Method meth = loc.method();
String methName = meth.declaringType().name() + '.' + meth.name();
String position = "";
if (meth.isNative()) {
position = " (native method)";
} else if (loc.lineNumber() != -1) {
position = ":" + loc.lineNumber();
} else {
long pc = loc.codeIndex();
if (pc != -1) {
position = ", pc = " + pc;
}
}
// Indices are presented to the user starting from 1, not 0.
this.setText("[" + (index + 1) + "] " + methName + position);
}
return this;
}
private void commandMethods(StringTokenizer t) throws NoSessionException {
if (!t.hasMoreTokens()) {
env.error("No class specified.");
return;
}
String idClass = t.nextToken();
ReferenceType cls = findClass(idClass);
if (cls != null) {
List<Method> methods = cls.allMethods();
OutputSink out = env.getOutputSink();
for (int i = 0; i < methods.size(); i++) {
Method method = methods.get(i);
out.print(method.declaringType().name() + " " + method.name() + "(");
Iterator<String> it = method.argumentTypeNames().iterator();
if (it.hasNext()) {
while (true) {
out.print(it.next());
if (!it.hasNext()) {
break;
}
out.print(", ");
}
}
out.println(")");
}
out.show();
} else {
// ### Should validate class name syntax.
env.failure("\"" + idClass + "\" is not a valid id or class name.");
}
}
private void dumpStack(ThreadReference thread, boolean showPC) {
// ### Check for these.
// env.failure("Thread no longer exists.");
// env.failure("Target VM must be in interrupted state.");
// env.failure("Current thread isn't suspended.");
// ### Should handle extremely long stack traces sensibly for user.
List<StackFrame> stack = null;
try {
stack = thread.frames();
} catch (IncompatibleThreadStateException e) {
env.failure("Thread is not suspended.");
}
// ### Fix this!
// ### Previously mishandled cases where thread was not current.
// ### Now, prints all of the stack regardless of current frame.
int frameIndex = 0;
// int frameIndex = context.getCurrentFrameIndex();
if (stack == null) {
env.failure("Thread is not running (no stack).");
} else {
OutputSink out = env.getOutputSink();
int nFrames = stack.size();
for (int i = frameIndex; i < nFrames; i++) {
StackFrame frame = stack.get(i);
Location loc = frame.location();
Method meth = loc.method();
out.print(" [" + (i + 1) + "] ");
out.print(meth.declaringType().name());
out.print('.');
out.print(meth.name());
out.print(" (");
if (meth.isNative()) {
out.print("native method");
} else if (loc.lineNumber() != -1) {
try {
out.print(loc.sourceName());
} catch (AbsentInformationException e) {
out.print("<unknown>");
}
out.print(':');
out.print(loc.lineNumber());
}
out.print(')');
if (showPC) {
long pc = loc.codeIndex();
if (pc != -1) {
out.print(", pc = " + pc);
}
}
out.println();
}
out.show();
}
}
public Method concreteMethodByName(String name, String signature) {
Method method = null;
for (Method candidate : visibleMethods()) {
if (candidate.name().equals(name)
&& candidate.signature().equals(signature)
&& !candidate.isAbstract()) {
method = candidate;
break;
}
}
return method;
}
@Override
public int compare(Method m1, Method m2) {
return LambdaMethodFilter.getLambdaOrdinal(m1.name())
- LambdaMethodFilter.getLambdaOrdinal(m2.name());
}
public static String methodName(final Method m) {
return methodName(signatureToName(m.declaringType().signature()), m.name(), m.signature());
}
/**
* Parses a method type definition
*
* @param docMethod
* @return
*/
protected static Method ParseMethod(MethodDoc docMethod) {
assert (docMethod != null);
Method xmlMethod = new Method();
xmlMethod.name = docMethod.name();
xmlMethod.hash = computeHash(docMethod.qualifiedName(), docMethod.signature());
xmlMethod.qualifiedName = docMethod.qualifiedName();
xmlMethod.comment = docMethod.commentText();
xmlMethod.signature = docMethod.signature();
xmlMethod.isNative = docMethod.isNative();
xmlMethod.isVarArgs = docMethod.isVarArgs();
xmlMethod.isSynchronized = docMethod.isSynchronized();
xmlMethod.isFinal = docMethod.isFinal();
xmlMethod.isAbstract = docMethod.isAbstract();
xmlMethod.isStatic = docMethod.isStatic();
xmlMethod.scope = DetermineScope(docMethod);
// Parse parameters of the method
Parameter[] parameters = docMethod.parameters();
if (parameters != null && parameters.length > 0) {
ParamTag[] paramComments = docMethod.paramTags();
ArrayList<Param> paramList = new ArrayList<Param>();
for (Parameter parameter : parameters) {
ParamTag paramComment = null;
// look to see if this parameter has comments
// if so, paramComment will be set
for (ParamTag testParam : paramComments) {
String testParamName = testParam.parameterName();
if (testParamName != null) {
if (testParamName.compareTo(parameter.name()) == 0) {
paramComment = testParam;
break;
}
}
}
paramList.add(ParseParameter(parameter, paramComment));
}
xmlMethod.parameters = paramList.toArray(new Param[] {});
} else {
log.debug("No parameters for method: " + docMethod.name());
}
// Parse result data
Result returnInfo = new Result();
Tag[] returnTags = docMethod.tags("@return");
if (returnTags != null && returnTags.length > 0) {
// there should be only one return tag. but heck,
// if they specify two, so what...
StringBuilder builder = new StringBuilder();
for (Tag returnTag : returnTags) {
String returnTagText = returnTag.text();
if (returnTagText != null) {
builder.append(returnTagText);
builder.append("\n");
}
}
returnInfo.comment = builder.substring(0, builder.length() - 1);
}
returnInfo.type = ParseType(docMethod.returnType());
xmlMethod.result = returnInfo;
// Parse exceptions of the method
Type[] types = docMethod.thrownExceptionTypes();
ThrowsTag[] exceptionComments = docMethod.throwsTags();
if (types != null && types.length > 0) {
ArrayList<ExceptionInstance> exceptionList = new ArrayList<ExceptionInstance>();
for (Type exceptionType : types) {
ExceptionInstance exception = new ExceptionInstance();
exception.type = ParseType(exceptionType);
for (ThrowsTag exceptionComment : exceptionComments) {
if (exceptionType == exceptionComment.exceptionType()) {
exception.comment = exceptionComment.exceptionComment();
ClassDoc exceptionDetails = exceptionComment.exception();
// not yet parsing Exceptions defined within the supplied code set
exception.type = ParseType(exceptionComment.exceptionType());
break;
}
}
exceptionList.add(exception);
}
xmlMethod.exceptions = exceptionList.toArray(new ExceptionInstance[] {});
}
// parse annotations from the method
xmlMethod.annotationInstances =
ParseAnnotationInstances(docMethod.annotations(), docMethod.qualifiedName());
return xmlMethod;
}
public void startElement(String uri, String localName, String name, Attributes attributes)
throws SAXException {
if (collectText) {
if (collectHTML) {
text.append("<").append(localName);
int nAttributes = attributes.getLength();
for (int i = 0; i < nAttributes; i++) {
String qname = attributes.getQName(i);
String value = attributes.getValue(i);
text.append(" ").append(qname).append("=\"").append(value).append("\"");
}
}
pendingEndElement = true;
} else {
Integer stateObj = null;
pushState();
if (NAMESPACE_API.equals(uri)) {
stateObj = (Integer) states.get(localName);
if (stateObj != null) {
int state = stateObj.intValue();
switch (state) {
case STATE_ABOUTME:
{
startCollectingText(localName, attributes);
break;
}
case STATE_ALIAS:
{
Alias alias = new Alias();
this.currentObject = alias;
addCollectionElement(TAG_ALIAS, alias);
alias.name = attributes.getValue(ATTRIBUTE_ALAIS_NAME);
alias.datatype = attributes.getValue(ATTRIBUTE_ALAIS_TYPE);
break;
}
case STATE_ANCESTOR:
{
Ancestor ancestor = new Ancestor();
this.currentObject = ancestor;
addCollectionElement(TAG_ANCESTOR, ancestor);
ancestor.dataType = attributes.getValue(ATTRIBUTE_ANCESTOR_DATATYPE);
break;
}
case STATE_API:
{
this.apis.libraryVersion = attributes.getValue(ATTRIBUTE_API_VERSION);
this.apis.language = attributes.getValue(ATTRIBUTE_API_LANGUAGE);
this.apis.getterPattern = attributes.getValue(ATTRIBUTE_API_GETTERPATTERN);
this.apis.setterPattern = attributes.getValue(ATTRIBUTE_API_SETTERPATTERN);
this.apis.setterPattern = attributes.getValue(ATTRIBUTE_API_SETTERPATTERN);
this.apis.spec = attributes.getValue(ATTRIBUTE_API_SPEC);
this.collections = new HashMap();
break;
}
case STATE_AUTHOR:
{
Author author = new Author();
this.currentObject = author;
author.email = attributes.getValue(ATTRIBUTE_AUTHOR_EMAIL);
author.location = attributes.getValue(ATTRIBUTE_AUTHOR_LOCATION);
author.name = attributes.getValue(ATTRIBUTE_AUTHOR_NAME);
author.organization = attributes.getValue(ATTRIBUTE_AUTHOR_ORGANIZATION);
author.photo = attributes.getValue(ATTRIBUTE_AUTHOR_PHOTO);
author.type = attributes.getValue(ATTRIBUTE_AUTHOR_TYPE);
author.website = attributes.getValue(ATTRIBUTE_AUTHOR_WEBSITE);
addCollectionElement(TAG_AUTHOR, author);
break;
}
case STATE_AVAILABLE:
{
DepreciatedOrAvailable available = new DepreciatedOrAvailable();
if (this.currentObject instanceof VersionableElement)
((VersionableElement) this.currentObject).available = available;
available.version = attributes.getValue(ATTRIBUTE_AVAILABLE_VERSION);
startCollectingText(localName, attributes);
break;
}
case STATE_CLASS:
case STATE_INTERFACE:
{
ClassData clazz = new ClassData();
this.currentObject = clazz;
if (STATE_INTERFACE == state) {
clazz.isInterface = true;
addCollectionElement(TAG_INTERFACE, clazz);
} else addCollectionElement(TAG_CLASS, clazz);
clazz.name = attributes.getValue(ATTRIBUTE_CLASS_NAME);
clazz.superclass = attributes.getValue(ATTRIBUTE_CLASS_SUPERCLASS);
clazz.visibility = attributes.getValue(ATTRIBUTE_CLASS_VISIBILITY);
clazz.getterPattern = attributes.getValue(ATTRIBUTE_CLASS_GETTERPATTERN);
clazz.setterPattern = attributes.getValue(ATTRIBUTE_CLASS_SETTERPATTERN);
this.collections = new HashMap();
break;
}
case STATE_CONSTRUCTOR:
case STATE_METHOD:
{
Method method = new Method();
if (STATE_CONSTRUCTOR == state) {
method.isContructor = true;
addCollectionElement(TAG_CONSTRUCTOR, method);
} else addCollectionElement(TAG_METHOD, method);
this.currentObject = method;
method.scope = attributes.getValue(ATTRIBUTE_CONSTRUCTOR_SCOPE);
method.visibility = attributes.getValue(ATTRIBUTE_CONSTRUCTOR_VISIBILITY);
method.name = attributes.getValue(ATTRIBUTE_METHOD_NAME);
this.collections = new HashMap();
break;
}
case STATE_DEPRECIATED:
{
DepreciatedOrAvailable depreciated = new DepreciatedOrAvailable();
if (this.currentObject instanceof VersionableElement)
((VersionableElement) this.currentObject).depreciated = depreciated;
depreciated.isDepreciated = true;
depreciated.version = attributes.getValue(ATTRIBUTE_DEPRECIATED_VERSION);
startCollectingText(localName, attributes);
break;
}
case STATE_DESCRIPTION:
{
startCollectingText(localName, attributes);
break;
}
case STATE_ENUM:
{
Enum enumData = new Enum();
this.currentObject = enumData;
addCollectionElement(TAG_ENUM, enumData);
enumData.name = attributes.getValue(ATTRIBUTE_ENUM_NAME);
enumData.datatype = attributes.getValue(ATTRIBUTE_ENUM_DATATYPE);
break;
}
case STATE_EVENT:
{
Event event = new Event();
this.currentObject = event;
addCollectionElement(TAG_EVENT, event);
this.collections = new HashMap();
break;
}
case STATE_EXCEPTION:
{
Exception exception = new Exception();
this.currentObject = exception;
addCollectionElement(TAG_EXCEPTION, exception);
this.collections = new HashMap();
break;
}
case STATE_FIELD:
case STATE_PROPERTY:
{
Property property = new Property();
this.currentObject = property;
if (STATE_FIELD == state) {
property.isField = true;
addCollectionElement(TAG_FIELD, property);
} else addCollectionElement(TAG_PROPERTY, property);
property.name = attributes.getValue(ATTRIBUTE_FIELD_NAME);
property.dataType = attributes.getValue(ATTRIBUTE_FIELD_DATATYPE);
property.scope = attributes.getValue(ATTRIBUTE_FIELD_SCOPE);
property.visibility = attributes.getValue(ATTRIBUTE_FIELD_VISIBILITY);
this.collections = new HashMap();
break;
}
case STATE_INCLUDE:
{
String src = attributes.getValue(ATTRIBUTE_INCLUDE_SRC);
handleInclude(src);
break;
}
case STATE_MIX:
{
Mix mix = new Mix();
addCollectionElement(TAG_MIX, mix);
this.currentObject = mix;
mix.datatype = attributes.getValue(ATTRIBUTE_MIX_DATATYPE);
mix.fromScope = attributes.getValue(ATTRIBUTE_MIX_FROMSCOPE);
mix.toScope = attributes.getValue(ATTRIBUTE_MIX_TOSCOPE);
break;
}
case STATE_MIXIN:
{
Mixin mixin = new Mixin();
addCollectionElement(TAG_MIXIN, mixin);
this.currentObject = mixin;
mixin.name = attributes.getValue(ATTRIBUTE_MIXIN_NAME);
mixin.scope = attributes.getValue(ATTRIBUTE_MIXIN_SCOPE);
mixin.visibility = attributes.getValue(ATTRIBUTE_MIXIN_VISIBILITY);
break;
}
case STATE_NAMESPACE:
{
Namespace namespace = new Namespace();
addCollectionElement(TAG_NAMESPACE, namespace);
this.currentObject = namespace;
namespace.name = attributes.getValue(ATTRIBUTE_NAMESPACE_NAME);
namespace.visibility = attributes.getValue(ATTRIBUTE_NAMESPACE_VISIBILITY);
break;
}
case STATE_PARAMETER:
{
Parameter parameter = new Parameter();
this.currentObject = parameter;
addCollectionElement(TAG_PARAMETER, parameter);
parameter.name = attributes.getValue(ATTRIBUTE_PARAMETER_NAME);
parameter.dataType = attributes.getValue(ATTRIBUTE_PARAMETER_DATATYPE);
parameter.usage = attributes.getValue(ATTRIBUTE_PARAMETER_USAGE);
this.collections = new HashMap();
break;
}
case STATE_QOUTE:
{
startCollectingText(localName, attributes);
break;
}
case STATE_RETURNS:
{
ReturnsData returnData = new ReturnsData();
if (this.currentObject instanceof Method)
((Method) this.currentObject).returns = returnData;
else if (this.currentObject instanceof Event)
((Event) this.currentObject).returns = returnData;
else if (this.currentObject instanceof Exception)
((Exception) this.currentObject).returns = returnData;
this.currentObject = returnData;
returnData.dataType = attributes.getValue(ATTRIBUTE_RETURNS_DATATYPE);
break;
}
}
this.currentState = state;
}
}
}
}
