public void addinstance(string classname) {    try {        class clazz = class.forname(classname);        objectset.add(clazz.newinstance());    }   catch (illegalaccessexception e) {        logger.log("exception in addinstance", e);    }    catch (instantiationexception e) {        logger.log("exception in addinstance", e);    }    catch (classnotfoundexception e) {        logger.log("exception in addinstance", e);    }}      

public void addinstance(string classname) {    try {        class clazz = class.forname(classname);        objectset.add(clazz.newinstance());    }    catch (exception e) {        logger.log("exception in newinstance", e);    }}      

public void addinstance(string classname) {    try {        class clazz = class.forname(classname);        objectset.add(clazz.newinstance());    }    catch (runtimeexception e) {        throw e;    }    catch (exception e) {        logger.log("exception in newinstance", e);    }}      

public class runtimeexceptioncapture extends bytecodescanningdetector {  private bugreporter bugreporter;  private method method;  private opcodestack stack = new opcodestack();  private list<exceptioncaught> catchlist;  private list<exceptionthrown> throwlist;  public void visitmethod(method method) {    this.method = method;    super.visitmethod(method)   }  public void visitcode(code obj) {    catchlist = new arraylist<exceptioncaught>();    throwlist = new arraylist<exceptionthrown>();    stack.resetformethodentry(this);    super.visitcode(obj);    // at this point, we've identified all the catch blocks    // more to come...  }  public void visit(codeexception obj) {    super.visit(obj);    int type = obj.getcatchtype();    if (type == 0) return;    string name =       getconstantpool().constanttostring(getconstantpool().getconstant(type));    exceptioncaught caughtexception =

new exceptioncaught(name, obj.getstartpc(), obj.getendpc(), obj.gethandlerpc());    catchlist.add(caughtexception);  }}      

public void sawopcode(int seen) {  stack.mergejumps(this);  try {      switch (seen) {      case athrow:          if (stack.getstackdepth() > 0) {              opcodestack.item item = stack.getstackitem(0);              string signature = item.getsignature();              if (signature != null && signature.length() > 0) {                  if (signature.startswith("l"))                      signature = signatureconverter.convert(signature);                  else                      signature = signature.replace('/', '.');                  throwlist.add(new exceptionthrown(signature, getpc()));              }          }          break;      case invokevirtual:      case invokespecial:      case invokestatic:          string classname = getdottedclassconstantoperand();          try {              if (!classname.startswith("[")) {                  javaclass clazz = repository.lookupclass(classname);                  method[] methods = clazz.getmethods();                  for (method method : methods) {                      if (method.getname().equals(getnameconstantoperand())                 && method.getsignature().equals(getsigconstantoperand())) {                          exceptiontable et = method.getexceptiontable();                          if (et != null) {                              string[] names = et.getexceptionnames();                              for (string name : names)                          throwlist.add(new exceptionthrown(name, getpc()));                          }                          break;                      }                  }              }          } catch (classnotfoundexception e) {              bugreporter.reportmissingclass(e);          }          break;      default:          break;      }  } finally {      stack.sawopcode(this, seen);  }}      

for (exceptioncaught caughtexception : catchlist) {    set<string> thrownset = new hashset<string>();    for (exceptionthrown thrownexception : throwlist) {        if (thrownexception.offset >= caughtexception.startoffset                && thrownexception.offset < caughtexception.endoffset) {            thrownset.add(thrownexception.exceptionclass);  if (thrownexception.exceptionclass.equals(caughtexception.exceptionclass))                caughtexception.seen = true;        }    }    int catchclauses = 0;    if (caughtexception.exceptionclass.equals("java.lang.exception")       && !caughtexception.seen) {        // now we have a case where exception is caught, but not thrown        boolean rtecaught = false;        for (exceptioncaught otherexception : catchlist) {            if (otherexception.startoffset == caughtexception.startoffset           && otherexception.endoffset == caughtexception.endoffset) {                catchclauses++;    if (otherexception.exceptionclass.equals("java.lang.runtimeexception"))                    rtecaught = true;            }        }        int range = caughtexception.endoffset - caughtexception.startoffset;        if (!rtecaught) {      bugreporter.reportbug(new buginstance(this, "rec_catch_exception",                    norm_priority)                    .addclassandmethod(this)                    .addsourceline(this, caughtexception.sourcepc));        }    }}      

if (!rtecaught) {    int priority = low_priority + 1;    if (range > 300) priority--;    else if (range < 30) priority++;    if (catchclauses > 1) priority++;    if (thrownset.size() > 1) priority--;    if (caughtexception.dead) priority--;    bugreporter.reportbug(new buginstance(this, "rec_catch_exception",            priority)            .addclassandmethod(this)            .addsourceline(this, caughtexception.sourcepc));}