View Javadoc
   /***
    * ClassLoader
    *
    * This is a superclass for all instrumenting class loaders.
    */
   
   package junit.quilt.cover.generic;
   
   import org.apache.commons.graph.Graph;
  
  import org.apache.bcel.Constants;
  
  import org.apache.bcel.generic.*;
  import org.apache.bcel.classfile.*;
  
  import java.lang.reflect.Field;
  
  import java.net.URL;
  import java.net.URLClassLoader;
  
  import java.io.File;
  import java.io.InputStream;
  
  import java.util.Enumeration;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.HashMap;
  import java.util.List;
  import java.util.ArrayList;
  
  public class QuiltClassLoader
      extends URLClassLoader
  {
      private String packages[] = null;
  
      publicQuiltClassLoader( String packages[],/index.html"> QuiltClassLoader( String packages[],
  			     URL path[] ) {
  	super( path );
  	this.packages = packages;
      }
  
      publicQuiltClassLoader( String packages[],/index.html"> QuiltClassLoader( String packages[],
  			     URL path[],
  			     ClassLoader parent ) {
  	super( path, parent );
  	this.packages = packages;
      }
  
      private Map addedStaticFields = new HashMap();
      // CLASS X LIST( AddedStaticField )
  
      private Map loadedClasses = new HashMap();
      // CLASS_NAME X JAVA_CLASS
  
      private static int lastField = 0;
  
      /***
       * AddedStaticField
       *
       * This class just keeps the field name that was generated,
       * and the data that is supposed to go in there together.
       */
      private class AddedStaticField
      {
  	public String fieldName = null;
  	public Object initData = null;
  
  	public AddedStaticField( String fieldName,
  				 Object initData ) 
  	{
  	    this.fieldName = fieldName;
  	    this.initData = initData;
  	}
      }
      
      /***
       * makeUniqueFieldName
       *
       * This method will create a unique field name for adding
       * data to a class.
       */
      private String makeUniqueFieldName() {
  	String RC = "junit_quilt_Field_" + lastField;
  	lastField++;
  	return RC;
      }
  
      /***
       * addStaticField
       *
       * This creates a unique static field on the class, and returns
       * a field reference which is valid in the current ConstantPool.
       *
       * The name is autogenerated.
       */
      protected int addStaticField( InstContext context,
  				  Type type, 
  				  Object initData) 
      {
 	ClassGen clazz = context.getClassGen();
 	ConstantPoolGen pool = context.getConstantPoolGen();
 
 	String fieldName = makeUniqueFieldName();
 	List fields = (List) addedStaticFields.get( clazz.getClassName() );
 	if (fields == null) {
 	    fields = new ArrayList();
 	    addedStaticFields.put( clazz.getClassName(), fields );
 	}
 	    
 	fields.add( new AddedStaticField( fieldName,
 					  initData ));
 	FieldGen field =
 	    new FieldGen( Constants.ACC_PUBLIC |
 			  Constants.ACC_STATIC,
 			  type,
 			  fieldName,
 			  pool );
 	clazz.addField( field.getField() );
 	return pool.addFieldref( clazz.getClassName(),
 				 fieldName,
 				 type.getSignature());
       
     }
 
     private boolean skip( String className ) {
 	for (int i = 0; i < packages.length; i++) {
 	    if (className.startsWith( packages[i] ))
 		return false;
 	}
 
 	System.err.println("Skipping: " + className );
 	return true;
     }
 
     protected JavaClass modifyClass( JavaClass clazz ) {
 	return clazz;
     }
 
     private JavaClass makeJavaClass( String className )
 	throws ClassNotFoundException
     {
 	try {
 	    String classFile = className.replace('.', File.pathSeparatorChar) 
 		+ ".class";
 	    URL bytecodeURL = getResource( classFile );
 	    InputStream bytecodeIS = bytecodeURL.openStream();
 
 	    return new ClassParser( bytecodeIS, className ).parse();
 	} catch (Exception e) {
 	    e.printStackTrace();
 	    throw new ClassNotFoundException( e.toString() );
 	}
     }
 
     public Class findClass( String className ) 
 	throws ClassNotFoundException
     {
 	if (skip( className )) 
 	    return super.findClass( className ) ;
 	
 	JavaClass clazz = null;
 
 	if (loadedClasses.containsKey( className )) {
 	    clazz = (JavaClass) loadedClasses.get( className );
 	} else {
 	    clazz = makeJavaClass( className );
 	    clazz = modifyClass( clazz );
 	}
 
 	byte bytecode[] = clazz.getBytes();
 	Class RC = defineClass( className, 
 				bytecode, 0, 
 				bytecode.length);
 
 	if (addedStaticFields.containsKey( className )) {
 	    Iterator addedFields =
 		((List) addedStaticFields.get( className )).iterator();
 	    while (addedFields.hasNext()) {
 		AddedStaticField af = (AddedStaticField) addedFields.next();
 		try {
 		    java.lang.reflect.Field field = 
 			RC.getField( af.fieldName );
 		    field.set( null, af.initData );
 		} catch (Exception e) {
 		    System.err.println("Warning: Field " + af.fieldName + 
 				       " not initialized.");
 		}
 	    }
 	}
 	return RC;
     }
 //      /***
 //       * This loads the class specified by the Class Name.
 //       *
 //       * After it is loaded, it will initialize all of the static
 //       * values which have been added to the system by the instrumentors.
 //       */
 //      public synchronized Class loadClass( String className ) 
 //  	throws ClassNotFoundException
 //      {
 //  	addedStaticFields.put( className, new ArrayList() );
 
 //  	Class RC = super.loadClass( className );
 
 //  	try {
 //  	    List fields = (List) addedStaticFields.get( className );
 //  	    if (fields != null) {
 //  		Iterator f = fields.iterator();
 		
 //  		while (f.hasNext()) {
 //  		    AddedStaticField asf = (AddedStaticField) f.next();
 //  		    java.lang.reflect.Field field 
 //  			= RC.getField( asf.fieldName );
 //  		    field.set( null, asf.initData );
 //  		}
 //  	    }
 //  	} catch (Exception e) {
 //  	    System.err.println("Warning: Coverage fields not initialized.");
 //  	    System.err.println("Class: " + className );
 //  	    e.printStackTrace();
 //  	}
 
 //  	return RC;
 //    }
 }