@CheckForNull GenericObjectType getLocalVariable(int index, int pos) { if (genericLocalVariables == null || !genericLocalVariables.get(index)) { return null; } for (LocalVariable local : localTypeTable.getLocalVariableTypeTable()) { if (local.getIndex() == index && local.getStartPC() <= pos && pos < +local.getStartPC() + local.getLength()) { String signature = local.getSignature(); if (signature.indexOf('<') < 0) { continue; } Type t; try { t = GenericUtilities.getType(signature); if (t instanceof GenericObjectType) { return (GenericObjectType) t; } } catch (RuntimeException e) { AnalysisContext.logError("Bad signature " + signature + " for " + local.getName(), e); } return null; } } return null; }
@Override public void visitLocalVariableTable(LocalVariableTable obj) { super.visitLocalVariableTable(obj); LocalVariable[] local_variable_table = obj.getLocalVariableTable(); for (LocalVariable aLocal_variable_table : local_variable_table) { aLocal_variable_table.accept(this); } }
private void printLocal(Writer out, Writer fout, LocalVariable l, int[] v, List<String> defs, List<String> refs) throws IOException { v[l.getIndex()] = 1; v[l.getNameIndex()] = 1; v[l.getSignatureIndex()] = 1; if (!THIS.equals(l.getName())) { out.write(TAB);out.write(TAB); fout.write(TAB);fout.write(TAB); String sig=Utility.signatureToString(l.getSignature()); out.write(sig); fout.write(sig); out.write(SPACE); fout.write(SPACE); String t; out.write(t = l.getName()); defs.add(t); refs.add(t); fout.write(t); out.write(EOL); fout.write(EOL); } }
public void setLocalTypeTable(LocalVariableTypeTable localTypeTable) { this.localTypeTable = localTypeTable; if (localTypeTable == null) { genericLocalVariables = null; } else { genericLocalVariables = new BitSet(); for(LocalVariable lv : localTypeTable.getLocalVariableTypeTable()) { if (lv.getSignature().indexOf('<') > 0) { genericLocalVariables.set(lv.getIndex()); } } } }
/** * Initialize from another object. Note that both objects use the same * references (shallow copy). Use copy() for a physical copy. */ public LocalVariable(LocalVariable c) { this(c.getStartPC(), c.getLength(), c.getNameIndex(), c.getSignatureIndex(), c.getIndex(), c.getConstantPool()); }
/** * returns the local variable at an index int the scope of PC * * @param lvt * the local variable table * @param index * the variable index * @param pc * the PC where the variable is used */ public static LocalVariable getLocalVariableAtPC(@Nonnull LocalVariableTable lvt, int index, int pc) { int length = lvt.getTableLength(); LocalVariable[] lvs = lvt.getLocalVariableTable(); for (int i = 0; i < length; i++) { if (lvs[i].getIndex() == index) { int startPC = lvs[i].getStartPC(); if ((pc >= startPC) && (pc < (startPC + lvs[i].getLength()))) { return lvs[i]; } } } return null; } }
/** * returns the end pc of the visible range of this register at this pc * * @param lvt * the local variable table for this method * @param reg * the register to examine * @param curPC * the pc of the current instruction * @return the endpc */ public static int getLocalVariableEndRange(LocalVariableTable lvt, int reg, int curPC) { int endRange = Integer.MAX_VALUE; if (lvt != null) { LocalVariable lv = lvt.getLocalVariable(reg, curPC); if (lv != null) { endRange = lv.getStartPC() + lv.getLength(); } } return endRange; }
@Override public void visit(LocalVariable obj) { if (isReservedName(obj.getName())) { LocalVariableAnnotation var = new LocalVariableAnnotation(obj.getName(), obj.getIndex(), obj.getStartPC()); SourceLineAnnotation source = SourceLineAnnotation.fromVisitedInstruction(getClassContext(), this, obj.getStartPC()); BugInstance bug = new BugInstance(this, "NM_FUTURE_KEYWORD_USED_AS_IDENTIFIER", NORMAL_PRIORITY) .addClassAndMethod(this).add(var).add(source); bugReporter.reportBug(bug); } }
private void adjustLocalVariableTypeTable(final LocalVariableTable lvt) { final LocalVariable[] lv = lvt.getLocalVariableTable(); final LocalVariable[] lvg = local_variable_type_table.getLocalVariableTypeTable(); for (final LocalVariable element : lvg) { for (final LocalVariable l : lv) { if (element.getName().equals(l.getName()) && element.getIndex() == l.getOrigIndex()) { element.setLength(l.getLength()); element.setStartPC(l.getStartPC()); element.setIndex(l.getIndex()); break; } } } }
LocalVariable localVariable = t.getLocalVariable(index, 0); if (localVariable != null) { String name = localVariable.getName(); if ("J".equals(s) && (name.toLowerCase().indexOf("instant") >= 0 || name.startsWith("date"))) {
/** * overrides the visitor to look for local variables where the name has 'Map', 'Set', 'List' in it but the type of that field isn't that. note that this * only is useful if compiled with debug labels. * * @param obj * the currently parsed method */ @Override public void visitMethod(Method obj) { LocalVariableTable lvt = obj.getLocalVariableTable(); if (lvt != null) { LocalVariable[] lvs = lvt.getLocalVariableTable(); for (LocalVariable lv : lvs) { if (checkConfusedName(lv.getName(), lv.getSignature())) { bugReporter.reportBug(new BugInstance(this, BugType.CNC_COLLECTION_NAMING_CONFUSION.name(), NORMAL_PRIORITY).addClass(this) .addString(lv.getName()).addSourceLine(this.clsContext, this, lv.getStartPC())); } } } }
LocalVariable lv = LVTHelper.getLocalVariableAtPC(varTable, register, getPC()); if (lv != null) { String objSignature = lv.getSignature(); if (objSignature.charAt(0) == 'L') { objSignature = objSignature.substring(1, objSignature.length() - 1).replace('/', '.');
name = lv.getName(); signature = lv.getSignature();
private static boolean isSuperpositionDetected(LocalVariable[] table, LocalVariable lvar) { for (LocalVariable localVariable : table) { if (lvar != localVariable && lvar.getName().equals(localVariable.getName()) && lvar.getStartPC() >= localVariable.getStartPC() && (lvar.getStartPC() + lvar.getLength() <= localVariable.getStartPC() + localVariable.getLength())) return true; } return false; }
/** @return first matching variable using index */ public final LocalVariable getLocalVariable(int index) { for(int i=0; i < local_variable_table_length; i++) if(local_variable_table[i].getIndex() == index) return local_variable_table[i]; return null; }
/** * BCEL-295: */ public void testB295() throws Exception { final JavaClass clazz = getTestClass(PACKAGE_BASE_NAME+".data.PLSETestClass2"); final ClassGen cg = new ClassGen(clazz); final ConstantPoolGen pool = cg.getConstantPool(); final Method m = cg.getMethodAt(1); // 'main' final LocalVariableTable lvt = m.getLocalVariableTable(); final LocalVariable lv = lvt.getLocalVariable(2, 4); // 'i' //System.out.println(lv); final MethodGen mg = new MethodGen(m, cg.getClassName(), pool); final LocalVariableTable new_lvt = mg.getLocalVariableTable(mg.getConstantPool()); final LocalVariable new_lv = new_lvt.getLocalVariable(2, 4); // 'i' //System.out.println(new_lv); assertEquals("live range length", lv.getLength(), new_lv.getLength()); } }
/** * Initialize from another object. Note that both objects use the same * references (shallow copy). Use copy() for a physical copy. */ public LocalVariable(final LocalVariable c) { this(c.getStartPC(), c.getLength(), c.getNameIndex(), c.getSignatureIndex(), c.getIndex(), c.getConstantPool()); this.orig_index = c.getOrigIndex(); }
/** * * @param index the variable slot * @param pc the current pc that this variable is alive * * @return the LocalVariable that matches or null if not found */ public final LocalVariable getLocalVariable( final int index, final int pc ) { for (final LocalVariable variable : local_variable_table) { if (variable.getIndex() == index) { final int start_pc = variable.getStartPC(); final int end_pc = start_pc + variable.getLength(); if ((pc >= start_pc) && (pc <= end_pc)) { return variable; } } } return null; }
/** * returns the end pc of the visible range of this register at this pc * * @param lvt * the local variable table for this method * @param reg * the register to examine * @param curPC * the pc of the current instruction * @return the endpc */ public static int getLocalVariableEndRange(LocalVariableTable lvt, int reg, int curPC) { int endRange = Integer.MAX_VALUE; if (lvt != null) { LocalVariable lv = lvt.getLocalVariable(reg, curPC); if (lv != null) { endRange = lv.getStartPC() + lv.getLength(); } } return endRange; }