public static void printSite(Site s, StringBuilder out) {
if (s == null) {
out.append("(null)");
return;
}
StackTraceElement[] st = s.site();
int interestingSitesPrinted = 0;
for (int i = s.offset; i < st.length; i++) {
StackTraceElement e = st[i];
String fileName = e.getFileName();
if (THIS_FILE_NAME.equals(fileName)) {
continue;
}
out.append(" " + e.getMethodName() + "(" + e.getFileName() + ":" + e.getLineNumber() + ")");
interestingSitesPrinted++;
if (interestingSitesPrinted <= SITES_TO_PRINT) {
continue;
}
if (fileName == null || "View.java".equals(fileName)) {
continue;
}
String methodName = e.getMethodName();
if (skipMethods.contains(methodName)) {
continue;
}
break;
}
}
/** Checks all of the methods in gen for consistency */
public static void checkMgens(final ClassGen gen) {
if (skip_checks) return;
Method[] methods = gen.getMethods();
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
// System.out.println ("Checking method " + method + " in class "
// + gen.getClassName());
checkMgen(new MethodGen(method, gen.getClassName(), gen.getConstantPool()));
}
if (false) {
Throwable t = new Throwable();
t.fillInStackTrace();
StackTraceElement[] ste = t.getStackTrace();
StackTraceElement caller = ste[1];
System.out.printf(
"%s.%s (%s line %d)",
caller.getClassName(),
caller.getMethodName(),
caller.getFileName(),
caller.getLineNumber());
for (int ii = 2; ii < ste.length; ii++)
System.out.printf(" [%s line %d]", ste[ii].getFileName(), ste[ii].getLineNumber());
System.out.printf("\n");
dump_methods(gen);
}
}
// Private method to infer the caller's class and method names
private void inferCaller() {
needToInferCaller = false;
// Android-changed: Use VMStack.getThreadStackTrace.
StackTraceElement[] stack = VMStack.getThreadStackTrace(Thread.currentThread());
int depth = stack.length;
boolean lookingForLogger = true;
for (int ix = 0; ix < depth; ix++) {
// Calling getStackTraceElement directly prevents the VM
// from paying the cost of building the entire stack frame.
//
// Android-changed: Use value from getThreadStackTrace.
StackTraceElement frame = stack[ix];
String cname = frame.getClassName();
boolean isLoggerImpl = isLoggerImplFrame(cname);
if (lookingForLogger) {
// Skip all frames until we have found the first logger frame.
if (isLoggerImpl) {
lookingForLogger = false;
}
} else {
if (!isLoggerImpl) {
// skip reflection call
if (!cname.startsWith("java.lang.reflect.") && !cname.startsWith("sun.reflect.")) {
// We've found the relevant frame.
setSourceClassName(cname);
setSourceMethodName(frame.getMethodName());
return;
}
}
}
}
// We haven't found a suitable frame, so just punt. This is
// OK as we are only committed to making a "best effort" here.
}
private void printScriptFrames(StringBuilder sb, Realm realm, Throwable e, int level) {
final String indent = Strings.repeat('\t', level);
final int maxDepth = options.stacktraceDepth;
int depth = 0;
StackTraceElement[] stackTrace = StackTraces.scriptStackTrace(e);
for (; depth < Math.min(stackTrace.length, maxDepth); ++depth) {
StackTraceElement element = stackTrace[depth];
String methodName = element.getMethodName();
String fileName = element.getFileName();
int lineNumber = element.getLineNumber();
sb.append(indent)
.append("at ")
.append(methodName)
.append(" (")
.append(fileName)
.append(':')
.append(lineNumber)
.append(")\n");
}
if (depth < stackTrace.length) {
int skipped = stackTrace.length - depth;
sb.append("\t.. ").append(skipped).append(" frames omitted\n");
}
if (e.getSuppressed().length > 0 && level == 1) {
Throwable suppressed = e.getSuppressed()[0];
String message;
if (suppressed instanceof ScriptException) {
message = ((ScriptException) suppressed).getMessage(realm.defaultContext());
} else {
message = Objects.toString(suppressed.getMessage(), suppressed.getClass().getSimpleName());
}
sb.append(indent).append(formatMessage("suppressed_exception", message)).append('\n');
printScriptFrames(sb, realm, suppressed, level + 1);
}
}
/**
* Prints out the given debug message to System.out, prefixed by the calling class name, method
* and line number, appending the stacktrace of the given exception.
*/
public static void out(final String _debug_msg, final Throwable _exception) {
String header = "DEBUG::";
header = header + new Date(SystemTime.getCurrentTime()).toString() + "::";
String className;
String methodName;
int lineNumber;
String trace_trace_tail = null;
try {
throw new Exception();
} catch (Exception e) {
StackTraceElement[] st = e.getStackTrace();
StackTraceElement first_line = st[2];
className = first_line.getClassName() + "::";
methodName = first_line.getMethodName() + "::";
lineNumber = first_line.getLineNumber();
trace_trace_tail = getCompressedStackTrace(e, 3, 200, false);
}
diagLoggerLogAndOut(header + className + (methodName) + lineNumber + ":", true);
if (_debug_msg.length() > 0) {
diagLoggerLogAndOut(" " + _debug_msg, true);
}
if (trace_trace_tail != null) {
diagLoggerLogAndOut(" " + trace_trace_tail, true);
}
if (_exception != null) {
diagLoggerLogAndOut(_exception);
}
}
public static void printElement(Site s, int index) {
if (s == null || index >= s.site().length) {
ps.print("(null)");
} else {
StackTraceElement e = s.site()[index];
ps.print(e.getMethodName() + " (" + e.getFileName() + ":" + e.getLineNumber() + ")");
}
}
private static void printElementInfo(OutputStream stream, StackTraceElement element) {
print(stream, element.getClassName());
print(stream, ":");
print(stream, element.getMethodName());
print(stream, " ");
print(stream, "(");
print(stream, element.getFileName());
print(stream, ":");
print(stream, element.getLineNumber());
print(stream, ")");
printNewLine(stream);
}
public static void printStackTrace(Throwable e, Object context) {
String header = "DEBUG::";
header = header + new Date(SystemTime.getCurrentTime()).toString() + "::";
String className = "?::";
String methodName = "?::";
int lineNumber = -1;
try {
throw new Exception();
} catch (Exception f) {
StackTraceElement[] st = f.getStackTrace();
for (int i = 1; i < st.length; i++) {
StackTraceElement first_line = st[i];
className = first_line.getClassName() + "::";
methodName = first_line.getMethodName() + "::";
lineNumber = first_line.getLineNumber();
// skip stuff generated by the logger
if (className.indexOf(".logging.") != -1 || className.endsWith(".Debug::")) {
continue;
}
break;
}
}
diagLoggerLogAndOut(header + className + (methodName) + lineNumber + ":", true);
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
PrintWriter pw = new PrintWriter(new OutputStreamWriter(baos));
if (context != null) {
pw.print(" ");
pw.println(context);
}
pw.print(" ");
e.printStackTrace(pw);
pw.close();
String stack = baos.toString();
diagLoggerLogAndOut(stack, true);
} catch (Throwable ignore) {
e.printStackTrace();
}
}
// [JACKSON-888]
public void testStackTraceElement() throws Exception {
StackTraceElement elem = null;
try {
throw new IllegalStateException();
} catch (Exception e) {
elem = e.getStackTrace()[0];
}
String json = MAPPER.writeValueAsString(elem);
StackTraceElement back = MAPPER.readValue(json, StackTraceElement.class);
assertEquals("testStackTraceElement", back.getMethodName());
assertEquals(elem.getLineNumber(), back.getLineNumber());
assertEquals(elem.getClassName(), back.getClassName());
assertEquals(elem.isNativeMethod(), back.isNativeMethod());
assertTrue(back.getClassName().endsWith("TestJdkTypes"));
assertFalse(back.isNativeMethod());
}
public static void printElements(Site s, int index, int nelems) {
if (s == null || index >= s.site().length) {
ps.print("(null)");
} else {
for (int i = 0; i < nelems; i++) {
int j = index + i;
if (j >= s.site().length) {
break;
}
if (i > 0) {
ps.print(", ");
}
StackTraceElement e = s.site()[j];
ps.print(e.getMethodName() + " (" + e.getFileName() + ":" + e.getLineNumber() + ")");
}
}
}
protected static boolean wasCalledDuringClassLoading() {
if (LOCK.isHeldByCurrentThread()) return true;
LOCK.lock();
try {
StackTrace st = new StackTrace(new Throwable());
int n = st.getDepth();
for (int i = 3; i < n; i++) {
StackTraceElement ste = st.getElement(i);
if ("ClassLoader.java".equals(ste.getFileName())
&& "loadClass".equals(ste.getMethodName())) {
return true;
}
}
return false;
} finally {
LOCK.unlock();
}
}
static StackTraceElement[] truncate(Throwable e, int depth) {
StackTraceElement[] stackTrace = e.getStackTrace();
if (stackTrace.length > depth) {
int omitted = stackTrace.length - depth;
stackTrace = Arrays.copyOf(stackTrace, depth + 1);
stackTrace[depth] = new StackTraceElement("..", "", "Frames omitted", omitted);
}
if (REMOVE_PACKAGE_NAME) {
for (int i = 0; i < stackTrace.length; ++i) {
StackTraceElement element = stackTrace[i];
String className = element.getClassName();
if (className.startsWith(PACKAGE_NAME)) {
stackTrace[i] =
new StackTraceElement(
className.substring(PACKAGE_NAME.length()),
element.getMethodName(),
element.getFileName(),
element.getLineNumber());
}
}
}
return stackTrace;
}
public static String stack(StackTraceElement stk) {
String className = stk.getClassName();
int idx = className.lastIndexOf('.');
if (idx >= 0) className = className.substring(idx + 1);
return className + "." + stk.getMethodName();
}
