private int getNextExecutableLineNumber(LineNumberTable linenumbers, int PC) { LineNumber[] entries = linenumbers.getLineNumberTable(); int beforePC = 0; int i = 0; for (; i < entries.length && entries[i].getStartPC() < PC; i++) { int line = entries[i].getLineNumber(); if (line > beforePC) { beforePC = line; } } if (i < entries.length) { int secondChoice = entries[i].getLineNumber(); for (; i < entries.length; i++) { int line = entries[i].getLineNumber(); if (line > beforePC) { return line; } } return secondChoice; } else { return entries[entries.length - 1].getLineNumber(); } }
++numGood; lineNumberMap.put(handle, new LineNumber(bytecodeOffset, sourceLine)); handle = handle.getNext(); ++numBytecodes;
@Override public void visitLineNumberTable(LineNumberTable obj) { super.visitLineNumberTable(obj); LineNumber[] line_number_table = obj.getLineNumberTable(); for (LineNumber aLine_number_table : line_number_table) { aLine_number_table.accept(this); } }
@Override public void visit(LineNumber obj) { sawLineNumbers = true; int line = obj.getLineNumber(); lines.set(line); }
if (line.getStartPC() > tightEndPC) { break; if (line.getStartPC() >= tightStartPC) { count++;
/** * @return deep copy of this attribute */ public Attribute copy(ConstantPool constant_pool) { LineNumberTable c = (LineNumberTable)clone(); c.line_number_table = new LineNumber[line_number_table_length]; for(int i=0; i < line_number_table_length; i++) c.line_number_table[i] = line_number_table[i].copy(); c.constant_pool = constant_pool; return c; }
/** * Dump line number table attribute to file stream in binary format. * * @param file Output file stream * @throws IOEXception if an I/O Exception occurs in writeShort */ @Override public final void dump( final DataOutputStream file ) throws IOException { super.dump(file); file.writeShort(line_number_table.length); for (final LineNumber lineNumber : line_number_table) { lineNumber.dump(file); } }
/** * @return String representation. */ public final String toString() { StringBuffer buf = new StringBuffer(); StringBuffer line = new StringBuffer(); for(int i=0; i < line_number_table_length; i++) { line.append(line_number_table[i].toString()); if(i < line_number_table_length - 1) line.append(", "); if(line.length() > 72) { line.append('\n'); buf.append(line); line.setLength(0); } } buf.append(line); return buf.toString(); }
public static int getNextSourceLine(LineNumberTable lineNumbers, int sourceLine) { int result = Integer.MAX_VALUE; for (LineNumber ln : lineNumbers.getLineNumberTable()) { int thisLine = ln.getLineNumber(); if (sourceLine < thisLine && thisLine < result) { result = thisLine; } } return result; } }
public int compare(LineNumber arg0, LineNumber arg1) { return arg0.getStartPC() - arg1.getStartPC(); }
/** * @return deep copy of this attribute */ @Override public Attribute copy( final ConstantPool _constant_pool ) { // TODO could use the lower level constructor and thereby allow // line_number_table to be made final final LineNumberTable c = (LineNumberTable) clone(); c.line_number_table = new LineNumber[line_number_table.length]; for (int i = 0; i < line_number_table.length; i++) { c.line_number_table[i] = line_number_table[i].copy(); } c.setConstantPool(_constant_pool); return c; }
/** * Dump line number table attribute to file stream in binary format. * * @param file Output file stream * @throws IOException */ public final void dump(DataOutputStream file) throws IOException { super.dump(file); file.writeShort(line_number_table_length); for(int i=0; i < line_number_table_length; i++) line_number_table[i].dump(file); }
/** * @return String representation. */ @Override public final String toString() { final StringBuilder buf = new StringBuilder(); final StringBuilder line = new StringBuilder(); final String newLine = System.getProperty("line.separator", "\n"); for (int i = 0; i < line_number_table.length; i++) { line.append(line_number_table[i].toString()); if (i < line_number_table.length - 1) { line.append(", "); } if ((line.length() > MAX_LINE_LENGTH) && (i < line_number_table.length - 1)) { line.append(newLine); buf.append(line); line.setLength(0); } } buf.append(line); return buf.toString(); }
private void checkTable(LineNumberTable table) { if (DEBUG) { System.out.println("line number table has length " + table.getTableLength()); } LineNumber[] entries = table.getLineNumberTable(); int lastBytecode = -1; for (int i = 0; i < entries.length; ++i) { LineNumber ln = entries[i]; if (DEBUG) { System.out.println("Entry " + i + ": pc=" + ln.getStartPC() + ", line=" + ln.getLineNumber()); } int pc = ln.getStartPC(); if (pc <= lastBytecode) { throw new IllegalStateException("LineNumberTable is not sorted"); } } }
/** * Create a SourceLineAnnotation covering an entire method. * * @param className * name of the class the method is in * @param sourceFile * source file containing the method * @param lineNumberTable * the method's LineNumberTable * @param codeSize * size in bytes of the method's code * @return a SourceLineAnnotation covering the entire method */ public static SourceLineAnnotation forEntireMethod(@DottedClassName String className, String sourceFile, LineNumberTable lineNumberTable, int codeSize) { LineNumber[] table = lineNumberTable.getLineNumberTable(); if (table != null && table.length > 0) { LineNumber first = table[0]; LineNumber last = table[table.length - 1]; return new SourceLineAnnotation(className, sourceFile, first.getLineNumber(), last.getLineNumber(), 0, codeSize - 1); } else { return createUnknown(className, sourceFile, 0, codeSize - 1); } }
if (line.getStartPC() > tightEndPC) { break; if (line.getStartPC() >= tightStartPC) { count++;
@Override public void visitLineNumber(final LineNumber number) { stack.push(number); number.accept(visitor); stack.pop(); }
/** * Construct object from file stream. * @param name_index Index of name * @param length Content length in bytes * @param file Input stream * @throws IOException * @param constant_pool Array of constants */ LineNumberTable(int name_index, int length, DataInputStream file, ConstantPool constant_pool) throws IOException { this(name_index, length, (LineNumber[])null, constant_pool); line_number_table_length = (file.readUnsignedShort()); line_number_table = new LineNumber[line_number_table_length]; for(int i=0; i < line_number_table_length; i++) line_number_table[i] = new LineNumber(file); } /**
if (lineNumberTable != null) { for (LineNumber line : lineNumberTable.getLineNumberTable()) { int newLine = line.getLineNumber(); if (newLine == lineNum || newLine == -1) { continue; if ( prevStartPc < nextPcInFinallyBlock && nextPcInFinallyBlock < line.getStartPC()) { lineMentionedMultipleTimes.set(lineNum); if (line.getStartPC() >= firstHandler) { afterHandler.set(lineNum); afterHandler.set(newLine); foundOnce.set(lineNum); prevStartPc = line.getStartPC();
static SourceLineAnnotation getSourceAnnotationForClass(String className, String sourceFileName) { int lastLine = -1; int firstLine = Integer.MAX_VALUE; try { JavaClass targetClass = AnalysisContext.currentAnalysisContext().lookupClass(className); for (Method m : targetClass.getMethods()) { Code c = m.getCode(); if (c != null) { LineNumberTable table = c.getLineNumberTable(); if (table != null) { for (LineNumber line : table.getLineNumberTable()) { lastLine = Math.max(lastLine, line.getLineNumber()); firstLine = Math.min(firstLine, line.getLineNumber()); } } } } } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); } if (firstLine < Integer.MAX_VALUE) { return new SourceLineAnnotation(className, sourceFileName, firstLine, lastLine, -1, -1); } return SourceLineAnnotation.createUnknown(className, sourceFileName); }