code: public static void verify(final ClassReader cr, final ClassLoader loader,
              final boolean dump, final PrintWriter pw) {
          ClassNode cn = new ClassNode();
          cr.accept(new CheckClassAdapter(cn, false), ClassReader.SKIP_DEBUG);
  
          Type syperType = cn.superName == null ? null : Type
                  .getObjectType(cn.superName);
          List<MethodNode> methods = cn.methods;
  
          List<Type> interfaces = new ArrayList<Type>();
          for (Iterator<String> i = cn.interfaces.iterator(); i.hasNext();) {
              interfaces.add(Type.getObjectType(i.next()));
          }
  
          for (int i = 0; i < methods.size(); ++i) {
              MethodNode method = methods.get(i);
              SimpleVerifier verifier = new SimpleVerifier(
                      Type.getObjectType(cn.name), syperType, interfaces,
                      (cn.access & Opcodes.ACC_INTERFACE) != 0);
              Analyzer<BasicValue> a = new Analyzer<BasicValue>(verifier);
              if (loader != null) {
                  verifier.setClassLoader(loader);
              }
              try {
                  a.analyze(cn.name, method);
                  if (!dump) {
                      continue;
                  }
              } catch (Exception e) {
                  e.printStackTrace(pw);
              }
              printAnalyzerResult(method, a, pw);
          }
          pw.flush();
      }
docs: Checks a given class.
  
  @param cr
  a <code>ClassReader</code> that contains bytecode for the
  analysis.
  @param loader
  a <code>ClassLoader</code> which will be used to load
  referenced classes. This is useful if you are verifiying
  multiple interdependent classes.
  @param dump
  true if bytecode should be printed out not only when errors
  are found.
  @param pw
  write where results going to be printed