package abbot.script;

 import java.awt.*;

 import java.util.EmptyStackException;

 import java.lang.reflect.Field;

 import javax.swing.SwingUtilities;

 import abbot.Log;

 import abbot.Platform;

 import abbot.i18n.Strings;

 import abbot.util.*;

 /**

  * A custom class loader which installs itself as if it were the application

  * class loader.  A classpath of null is equivalent to the system property

  * java.class.path.<p> 

  * The class loader may optionally load a class <i>before</i> the parent class

  * loader gets a chance to look for the class (instead of the default

  * behavior, which always delegates to the parent class loader first).  This

  * behavior enables the class to be reloaded simply by using a new instance of

  * this class loader with each launch of the app.<p>  

  * This class mimics the behavior of sun.misc.Launcher$AppClassLoader as much

  * as possible.<p>

  * Bootstrap classes are always delegated to the bootstrap loader, with the

  * exception of the sun.applet package, which should never be delegated, since

  * it does not work properly unless it is reloaded.<p>  

  * The parent of this class loader will be the normal, default AppClassLoader

  * (specifically, the class loader which loaded this class will be used).

  */

     /** A new event queue installed for the lifetime of this class loader. */

     private AppEventQueue eventQueue;

     /** This class loader is used to load bootstrap classes that must be

      * preloaded.

      */

     private BootstrapClassLoader bootstrapLoader;

     /** For use in checking if a class is in the framework class path. */

     private NonDelegatingClassLoader extensionsLoader;

     /** Whether the framework itself is being tested. */

     private boolean frameworkIsUnderTest = false;

     /** Old class loader context for the thread where this loader was

      * installed.

      */

     private ClassLoader oldClassLoader = null;

     private Thread installedThread = null;

     private String oldClassPath = null;

     private InstallationLock lock = new InstallationLock();

     /** Constructs an AppClassLoader using the current classpath (as found in

         java.class.path).

     */

     }

     /**

      * Constructs a AppClassLoader with a custom classpath, indicating

      * whether the class loader should delegate to its parent class loader

      * prior to searching for a given resource.<p>

      * The class path argument may use either a colon or semicolon to separate

      * its elements.<p>

      */

         // Use this one to look up extensions; we want to reload them, but may

         // need to look in the framework class path for them.  

         // Make sure it *only* loads extensions, though, and defers all other

         // lookups to its parent.

             new NonDelegatingClassLoader(System.getProperty("java.class.path"),

                                          AppClassLoader.class.

                                          getClassLoader()) {

                 }

             };

         // Don't want to open a whole new can of class loading worms!

         /*

         // If we're testing the framework itself, then absolutely DO NOT

         // delegate those classes. 

         if (getClassPath().indexOf("abbot.jar") != -1) {

             frameworkIsUnderTest = true;

         }

         */

     }

             && Thread.currentThread() == eventQueue.thread)

             || (eventQueue == null

                 && SwingUtilities.isEventDispatchThread());

     }

     /** Should the parent class loader try to load this class first? */

     // FIXME we should only need the delegate flag if stuff in the classpath

     // is also found on the system classpath, e.g. the framework itself

     // Maybe just set it internally in case the classpaths overlap?

             && !isExtension(name)

             && !(frameworkIsUnderTest && isFrameworkClass(name));

     }

             || name.startsWith("junit.extensions.abbot.");

     }

             || name.startsWith("abbot.script.parsers.extensions.");

     }

     /**

      * Finds and loads the class with the specified name from the search

      * path.  If the class is a bootstrap class and must be preloaded, use our

      * own bootstrap loader.  If it is an extension class, use our own

      * extensions loader.

      *

      * @param name the name of the class

      * @return the resulting class

      * @exception ClassNotFoundException if the class could not be found

      */

             }

             catch(ClassNotFoundException cnf) {

             }

         }

         // Look for extensions first in the framework class path (with a

         // special loader), then in the app class path.

         // Extensions *must* have the same class loader as the corresponding

         // custom components

         }

         catch(ClassNotFoundException cnf) {

             }

         }

     }

     /** Ensure that everything else subsequently loaded on the same thread or

      * any subsequently spawned threads uses the given class loader.  Also

      * ensure that classes loaded by the event dispatch thread and threads it

      * spawns use the given class loader.

      */

         }

                                      new Object[] { installedThread });

         }

         // Change the effective classpath, but make sure it's available if

         // someone needs to access it.

                   + System.getProperty("java.class.path"));

         // Install our own handler for catching exceptions on the event

         // dispatch thread.

         }

         catch(Exception e) {

             // ignore any exceptions, since they're not fatal

         }

     }

     /** Reverse the effects of install.   Has no effect if the class loader

      * has not been installed on any thread.

      */

         // Ensure that no two threads attempt to uninstall 

             }

             }

         }

     }

         private Thread thread;

         /** Ensure the class loader for the event dispatch thread is the right

             one.

         */

                         getSystemEventQueue().push(AppEventQueue.this);

                 }

             };

             // Avoid deadlock with the event queue, in case it has the tree

             // lock (pickens). 

                 }

             };

         }

         /** Pop this and any subsequently pushed event queues. */

             }

             catch(EmptyStackException ese) {

             }

         }

         }

     }

     /** List of bootstrap classes we most definitely want to be loaded by this

      * class loader, rather than any parent, or the bootstrap loader.

      */

     private String[] mustReloadPrefixes = {

         "sun.applet.",  // need the whole package, not just AppletViewer/Main

     };

     /** Does the given class absolutely need to be preloaded? */

         }

     }

     /** Returns the path to the primary JRE classes, not including any

      * extensions.  This is primarily needed for loading

      * sun.applet.AppletViewer/Main, since most other classes in the bootstrap

      * path should <i>only</i> be loaded by the bootstrap loader.

      */

     }

     /** Provide access to bootstrap classes that we need to be able to

      * reload.

      */ 

         }

             // Exclude all bootstrap classes, except for those we know we

             // *must* be reloaded on each run in order to have function

             // properly (e.g. applet)  

                 && !"abbot.script.AppletSecurityManager".equals(name);

         }

     }

             + System.getProperty("java.class.path") + ")";

     }

 }