<target name="boot">

    <javac srcdir="src" destdir="src" deprecation="${build.compiler.deprecation}" debug="${build.compiler.debug}" 

        includes="org/netbeans/*java"

    />    

    <mkdir dir="netbeans/lib/ext" />

    <jar jarfile="netbeans/lib/ext/boot.jar"

            basedir="src"

            excludesfile="../nbbuild/standard-jar-excludes.txt"

            includes="org/netbeans/*class" 

	    compress="false">

    </jar>

  </target>

            excludes="org/netbeans/*class"

/*

 *                 Sun Public License Notice

 * 

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 * 

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2001 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans;

import java.net.URL;

import java.util.jar.JarFile;

import java.util.jar.Manifest;

import java.util.jar.Attributes;

import java.util.jar.Attributes.Name;

import java.util.zip.ZipEntry;

import java.io.*;

import java.net.MalformedURLException;

import java.security.*;

import java.security.cert.Certificate;

import java.util.*;

import java.lang.reflect.Field;

import java.lang.reflect.Modifier;

/**

 * A ProxyClassLoader capable of loading classes from a set of jar files

 * and local directories.

 *

 * @author  Petr Nejedly

 */

public class JarClassLoader extends ProxyClassLoader {

    private Source[] sources;

    /** temp copy JARs which ought to be deleted */

    private Set deadJars = null; // Set<JarFile>

    /** Creates new JarClassLoader */

    public JarClassLoader (List files, ClassLoader[] parents) {

        super(parents);

        sources = new Source[files.size()];

        try {

            int i=0;

            for (Iterator it = files.iterator(); it.hasNext(); i++ ) {

                Object act = it.next();

                if (act instanceof File) {

                    sources[i] = new DirSource((File)act);

                } else {

                    sources[i] = new JarSource((JarFile)act);

                }

            }

        } catch (MalformedURLException exc) {

            throw new IllegalArgumentException(exc.getMessage());

        }

    }

    /** Allows to specify the right permissions, OneModuleClassLoader does it differently.

     */

    protected PermissionCollection getPermissions( CodeSource cs ) {           

        return Policy.getPolicy().getPermissions(cs);       

    }        

    protected Package definePackage(String name, Manifest man, URL url)

	throws IllegalArgumentException

    {

        if (man == null ) {

            return definePackage(name, null, null, null, null, null, null, null);

        }

	String path = name.replace('.', '/').concat("/"); // NOI18N

	Attributes spec = man.getAttributes(path);

        Attributes main = man.getMainAttributes();

        String specTitle = getAttr(spec, main, Name.SPECIFICATION_TITLE);

        String implTitle = getAttr(spec, main, Name.IMPLEMENTATION_TITLE);

        String specVersion = getAttr(spec, main, Name.SPECIFICATION_VERSION);

        String implVersion = getAttr(spec, main, Name.IMPLEMENTATION_VERSION);

        String specVendor = getAttr(spec, main, Name.SPECIFICATION_VENDOR);

        String implVendor = getAttr(spec, main, Name.IMPLEMENTATION_VENDOR);

        String sealed      = getAttr(spec, main, Name.SEALED);

        URL sealBase = "true".equalsIgnoreCase(sealed) ? url : null; // NOI18N

	return definePackage(name, specTitle, specVersion, specVendor,

			     implTitle, implVersion, implVendor, sealBase);

    }

    private static String getAttr(Attributes spec, Attributes main, Name name) {

        String val = null;

        if (spec != null) val = spec.getValue (name);

        if (val == null && main != null) val = main.getValue (name);

        return val;

    }

    protected Class simpleFindClass(String name, String path) {

        // look up the Sources and return a class based on their content

        for( int i=0; i<sources.length; i++ ) {

            Source src = sources[i];

            byte[] data = src.getClassData(name, path);

            if (data == null) continue;

            // do the enhancing

            byte[] d = PatchByteCode.patch (data);

            data = d;

            int j = name.lastIndexOf('.');

            String pkgName = name.substring(0, j);

            Package pkg = getPackage(pkgName);

            if (pkg != null) {

                // XXX full sealing check, URLClassLoader does something more

                if (pkg.isSealed() && !pkg.isSealed(src.getURL())) throw new SecurityException("sealing violation"); // NOI18N

            } else {

                Manifest man = src.getManifest();

                definePackage (pkgName, man, src.getURL());

            }

            return defineClass (name, data, 0, data.length, src.getProtectionDomain());

        } 

        return null;

    }

    // look up the jars and return a resource based on a content of jars

    protected URL findResource(String name) {

        for( int i=0; i<sources.length; i++ ) {

            URL item = sources[i].getResource(name);

            if (item != null) return item;

        }

	return null;

    }

    protected Enumeration simpleFindResources(String name) {

        Vector v = new Vector(3);

        // look up the jars and return a resource based on a content of jars

        for( int i=0; i<sources.length; i++ ) {

            URL item = sources[i].getResource(name);

            if (item != null) v.add(item);

        }

        return v.elements();

    }

    /** Try to release any JAR locks held by this classloader.

     * @see #21114

     */

    public final void releaseLocks() {

        if (deadJars != null) throw new IllegalStateException();

        deadJars = new HashSet(); // Set<JarFile>

        try {

            for (int i = 0; i < sources.length; i++) {

                if (sources[i] instanceof JarSource) {

                    JarFile origJar = ((JarSource)sources[i]).getJarFile();

                    File orig = new File(origJar.getName());

                    if (!orig.isFile()) {

                        // Can happen when a test module is deleted:

                        // the physical JAR has already been deleted

                        // when the module was disabled. In this case it

                        // is possible that a classloader request for something

                        // in the JAR could still come in. Does it matter?

                        // See comment in Module.cleanup.

                        continue;

                    }

                    String name = orig.getName();

                    String prefix, suffix;

                    int idx = name.lastIndexOf('.');

                    if (idx == -1) {

                        prefix = name;

                        suffix = null;

                    } else {

                        prefix = name.substring(0, idx);

                        suffix = name.substring(idx);

                    }

                    while (prefix.length() < 3) prefix += "x"; // NOI18N

                    File temp = File.createTempFile(prefix, suffix);

                    temp.deleteOnExit();

                    InputStream is = new FileInputStream(orig);

                    try {

                        OutputStream os = new FileOutputStream(temp);

                        try {

                            byte[] buf = new byte[4096];

                            int j;

                            while ((j = is.read(buf)) != -1) {

                                os.write(buf, 0, j);

                            }

                        } finally {

                            os.close();

                        }

                    } finally {

                        is.close();

                    }

                    // Don't use OPEN_DELETE even though it sounds like a good idea.

                    // Can cause real problems under 1.4; see Module.java.

                    JarFile tempJar = new JarFile(temp);

                    origJar.close();

                    forceRelease(orig);

                    deadJars.add(tempJar);

                    sources[i] = new JarSource(tempJar);

                    log("#21114: replacing " + orig + " with " + temp);

                }

            }

        } catch (IOException ioe) {

            JarClassLoader.notify(0, ioe);

        }

    }

    /** Release jar: locks when the classloader is shut down.

     * Should help reloading modules with changed resources.

     */

    public void destroy() {

        super.destroy();

        for (int i = 0; i < sources.length; i++) {

            if (sources[i] instanceof JarSource) {

                JarFile j = ((JarSource)sources[i]).getJarFile();

                File f = new File(j.getName());

                forceRelease(f);

            }

        }

    }

    /** Delete any temporary JARs we were holding on to.

     * Also close any other JARs in our list.

     */

    protected void finalize() throws Throwable {

        super.finalize();

        for (int i = 0; i < sources.length; i++) {

            if (sources[i] instanceof JarSource) {

                JarFile j = ((JarSource)sources[i]).getJarFile();

                File f = new File(j.getName());

                j.close();

                forceRelease(f);

                if (deadJars != null && deadJars.contains(j)) {

                    log("#21114: closing and deleting temporary JAR " + f);

                    if (f.isFile() && !f.delete()) {

                        log("(but failed to delete it)");

                    }

                }

            }

        }

    }

    /** Make sure the Java runtime's jar: URL cache is not holding

     * onto the specified file.

     * Workaround for JDK bug #4646668.

     */

    private static void forceRelease(File f) {

        if (fileCache == null || factory == null) return;

        try {

            synchronized (factory) {

                Iterator it = fileCache.values().iterator();

                while (it.hasNext()) {

                    JarFile j = (JarFile)it.next();

                    if (f.equals(new File(j.getName()))) {

                        j.close();

                        it.remove();

                        log("Removing jar: cache for " + f + " as workaround for JDK #4646668");

                    }

                }

            }

        } catch (Exception e) {

            JarClassLoader.annotate(e, 0, "Could not remove jar: cache for " + f, null, null, null);

            JarClassLoader.notify(0, e);

        }

    }

    private static Object factory = null;

    private static HashMap fileCache = null;

    static {

        try {

            Class juc = Class.forName("sun.net.www.protocol.jar.JarURLConnection"); // NOI18N

            Field factoryF = juc.getDeclaredField("factory"); // NOI18N

            factoryF.setAccessible(true);

            factory = factoryF.get(null);

            Class jff = Class.forName("sun.net.www.protocol.jar.JarFileFactory"); // NOI18N

            if (!jff.isInstance(factory)) throw new ClassCastException(factory.getClass().getName());

            Field fileCacheF = jff.getDeclaredField("fileCache"); // NOI18N

            fileCacheF.setAccessible(true);

            if (Modifier.isStatic(fileCacheF.getModifiers())) {

                // JDK 1.3.1 or 1.4 seems to have it static.

                fileCache = (HashMap)fileCacheF.get(null);

            } else {

                // But in 1.3.0 it appears to be an instance var.

                fileCache = (HashMap)fileCacheF.get(factory);

            }

            log("Workaround for JDK #4646668 active as part of IZ #21114");

        } catch (Exception e) {

            JarClassLoader.annotate(e, 0, "Workaround for JDK #4646668 as part of IZ #21114 failed", null, null, null);

            JarClassLoader.notify(0, e);

        }

    }

    abstract class Source {

        private URL url;

        private ProtectionDomain pd;

        public Source(URL url) {

            this.url = url;

            CodeSource cs = new CodeSource(url, new Certificate[0]);

            pd = new ProtectionDomain(cs, getPermissions(cs));

        }

        public final URL getURL() {

            return url;

        }

        public final ProtectionDomain getProtectionDomain() {

            return pd;

        }

        public final URL getResource(String name) {

            try {

                return doGetResource(name);

            } catch (MalformedURLException e) {

                log(e.toString());

            }

            return null;

        }

        protected abstract URL doGetResource(String name) throws MalformedURLException;

        public final byte[] getClassData(String name, String path) {

            try {

                return readClass(name, path);

            } catch (IOException e) {

                log(e.toString());

            }

            return null;

        }

        protected abstract byte[] readClass(String name, String path) throws IOException;

        public Manifest getManifest() {

            return null;

        }

    }

    class JarSource extends Source {

        JarFile src;

        public JarSource(JarFile file) throws MalformedURLException {

            super(new URL("file:" + file.getName()));

            src = file;

        }

        public Manifest getManifest() {

            try {

                return src.getManifest();

            } catch (IOException e) {

                return null;

            }

        }

        JarFile getJarFile() {

            return src;

        }

        protected URL doGetResource(String name) throws MalformedURLException {

            ZipEntry ze = src.getEntry(name);

            return ze == null ? null : new URL("jar:file:" + src.getName() + "!/" + ze.getName()); // NOI18N

        }

        protected byte[] readClass(String name, String path) throws IOException {

            ZipEntry ze = src.getEntry(path);

            if (ze == null) return null;

            int len = (int)ze.getSize();

            byte[] data = new byte[len];

            InputStream is = src.getInputStream(ze);

            int count = 0;

            while (count < len) {

                count += is.read(data, count, len-count);

            }

            return data;

        }

    }

    class DirSource extends Source {

        File dir;

        public DirSource(File file) throws MalformedURLException {

            super(file.toURL());

            dir = file;

        }

        protected URL doGetResource(String name) throws MalformedURLException {

            File resFile = new File(dir, name);

            return resFile.exists() ? resFile.toURL() : null;

        }

        protected byte[] readClass(String name, String path) throws IOException {

            File clsFile = new File(dir, path.replace('/', File.separatorChar));

            if (!clsFile.exists()) return null;

            int len = (int)clsFile.length();

            byte[] data = new byte[len];

            InputStream is = new FileInputStream(clsFile);

            int count = 0;

            while (count < len) {

                count += is.read(data, count, len-count);

            }

            return data;

        }

    }

    //

    // ErrorManager's methods

    //

    static void log (String msg) {

        System.err.println(msg);

    }

    static Throwable annotate (

        Throwable t, int x, String s, Object o1, Object o2, Object o3

    ) {

        System.err.println("annotated: " + t.getMessage () + " - " + s);

        return t;

    }

    static void notify (int x, Throwable t) {

        t.printStackTrace();

    }

}

import java.io.File;

import java.net.URL;

import java.net.URLClassLoader;

import java.util.ArrayList;

import java.util.StringTokenizer;

import java.lang.reflect.Method;

import java.util.Collection;

/*

 *                 Sun Public License Notice

 * 

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 * 

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2002 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans;

import java.io.*;

/** Class that can enhance bytecode with information about alternative

 * superclass and also extract this information later when the class

 * is about to be loaded into the VM.

 *

 * @author  Jaroslav Tulach

 */

public final class PatchByteCode {

    private static final String ATTR_SUPERCLASS = "org.netbeans.superclass"; // NOI18N

    private static final byte[] BYTE_SUPERCLASS;

    static {

        try {

            BYTE_SUPERCLASS = ATTR_SUPERCLASS.getBytes("utf-8"); // NOI18N

        } catch (java.io.UnsupportedEncodingException ex) {

            throw new IllegalStateException (ex.getMessage());

        }

    }

    private byte[] arr;

    private int cpCount;

    private int cpEnd;

    private int atCount;

    private int atEnd;

    /** the index of a string that matches the searched attribute */

    private int superClassNameIndex;

    /** the possiton of found attribute */

    private int superClassNameAttr;

    /** Creates a new instance of PatchByteCode */

    private PatchByteCode(byte[] arr) {

        this.arr = arr;

        scan ();

    }

    /** Generates patch attribute into the classfile to

     * allow method <code>patch</code> to modify the superclass of this 

     * class.

     *

     * @param arr the bytecode to change

     * @param superClass name of the new superclass like java/awt/Button

     * @return new version of the bytecode if changed, otherwise null to signal that

     * no change has been made

     */

    public static byte[] enhance (byte[] arr, String superClass) {

        if (isPatched (arr)) {

            // already patched

            return null;

        }

        PatchByteCode pc = new PatchByteCode (arr); 

        if (superClass != null) {

            int x = pc.addClass (superClass);

            byte[] sup = new byte[2];

            writeU2 (sup, 0, x);

            pc.addAttribute (ATTR_SUPERCLASS, sup);

            byte[] patch = { 

                'n', 'b' // identification at the end of class file

            };

            pc.addAttribute ("org.netbeans.enhanced", patch);

        }

        // if we patch the class then it is supposed to be public

        if (!pc.makePublic () && superClass == null) {

            // if it already was public and no superclass change

            return null;

        }

        // otherwise do the patching

        return pc.getClassFile ();

    }

    /** Checks if the class has previously been enhanced by the 

     * change of superclass attribute and if so, changes the bytecode

     * to reflect the change.

     * 

     * @param arr the bytecode

     * @return the enhanced bytecode

     */

    public static byte[] patch (byte[] arr) {

        if (!isPatched (arr)) return arr;

        PatchByteCode pc = new PatchByteCode (arr);

        if (pc.superClassNameAttr > 0) {

            // let's patch

            int classindex = pc.readU2 (pc.superClassNameAttr + 6);

            writeU2 (pc.getClassFile(), pc.cpEnd + 4, classindex);

        }

        return pc.getClassFile ();

    }

    /** Check if the byte code is patched.

     * @param arr the bytecode

     * @return true if patched

     */

    private static boolean isPatched (byte[] arr) {

        if (arr == null || arr.length < 2) return false;

        int base = arr.length - 2;

        if (arr[base + 1] != 'b') return false;

        if (arr[base + 0] != 'n') return false;

        //

        // ok, looks like enhanced byte code

        //

        return true;

    }

    /** Gets the current byte array of the actual class file.

     * @return bytes of the class file

     */

    private byte[] getClassFile () {

        return arr;

    }

    /** Creates new contant pool entry representing given class.

     * @param c name of the class

     * @return index of the entry

     */

    private int addClass (String s) {

        int x = addConstant (s);

        byte[] t = { 7, 0, 0 };

        writeU2 (t, 1, x);

        return addPool (t);

    }

    /** Adds a new string constant to the constant pool.

     * @param s the string to add

     * @return index of the constant

     */

    private int addConstant (String s) {

        byte[] t;

        try {

            t = s.getBytes("utf-8"); // NOI18N

        } catch (java.io.UnsupportedEncodingException ex) {

            throw new IllegalStateException ("UTF-8 shall be always supported"); // NOI18N

        }

        byte[] add = new byte[t.length + 3];

        System.arraycopy (t, 0, add, 3, t.length);

        add[0] = 1; // UTF8 contant

        writeU2 (add, 1, t.length);

        return addPool (add);

    }

    /** Adds this array of bytes as another entry into the constant pool */

    private int addPool (byte[] add) {

        byte[] res = new byte[arr.length + add.length];

        System.arraycopy (arr, 0, res, 0, cpEnd);

        // increments number of objects in contant pool

        int index = readU2 (cpCount);

        writeU2 (res, cpCount, index + 1);

        // adds the content

        System.arraycopy (add, 0, res, cpEnd, add.length);

        // and now add the rest of the original array

        System.arraycopy (arr, cpEnd, res, cpEnd + add.length, arr.length - cpEnd);

        arr = res;

        cpEnd += add.length;

        atCount += add.length;

        atEnd += add.length;

        // the index

        return index;

    }

    /** Ensures that the class is public 

     * @return true if really patched, false if not

     */

    private boolean makePublic () {

        int x = readU2 (cpEnd);

        if ((x & 0x0001) != 0) {

            return false;

        }

        x |= 0x0001; // adds public field

        writeU2 (arr, cpEnd, x);

        return true;

    }

    /** Adds an attribute to the class file.

     * @param name name of the attribute to add

     * @param b the bytes representing the attribute

     */

    private void addAttribute (String name, byte[] b) {

        int index;

        if (ATTR_SUPERCLASS.equals (name) && superClassNameIndex > 0) {

            index = superClassNameIndex;

        } else {

            // register new attribute

            index = addConstant (name);

        }

        byte[] res = new byte[arr.length + b.length + 6];

        System.arraycopy(arr, 0, res, 0, arr.length);

        writeU2 (res, arr.length, index);

        writeU4 (res, arr.length + 2, b.length);

        int begin = arr.length + 6;

        System.arraycopy(b, 0, res, begin, b.length);

        atEnd += b.length + 6;

        writeU2 (res, atCount, readU2 (atCount) + 1);

        arr = res;

    }

    /** Gets i-th element from the array.

     */

    private int get (int pos) {

        if (pos >= arr.length) {

            throw new ArrayIndexOutOfBoundsException ("Size: " + arr.length + " index: " + pos);

        }

        int x = arr[pos];

        return x >= 0 ? x : 256 + x;

    }

    /** Scans the file to find out important possitions

     * @return size of the bytecode

     */

    private void scan () {

        if (get (0) != 0xCA && get (1) != 0xFE && get (2) != 0xBA && get (3) != 0xBE) {

            throw new IllegalStateException ("Not a class file!"); // NOI18N

        }

        int pos = 10;

        // count of items in CP is here

        cpCount = 8;

        int cp = readU2 (8);

        for (int[] i = { 1 }; i[0] < cp; i[0]++) {

            // i[0] can be incremented in constantPoolSize

            int len = constantPoolSize (pos, i);

            pos += len;

        }

        // list item in constant pool

        cpEnd = pos;

        pos += 6;

        // now add interfaces

        pos += 2 * readU2 (pos);

        // to add also the integer with interfaces

        pos += 2;

        // fields

        int fields = readU2 (pos);

        pos += 2;

        while (fields-- > 0) {

            pos += fieldSize (pos);

        }

        int methods = readU2 (pos);

        pos += 2;

        while (methods-- > 0) {

            pos += methodSize (pos);

        }

        // count of items in Attributes is here

        atCount = pos;

        int attrs = readU2 (pos);

        pos += 2;

        while (attrs-- > 0) {

            pos += attributeSize (pos);

        }

        // end of attributes

        atEnd = pos;

    }

    private int readU2 (int pos) {

        int b1 = get (pos);

        int b2 = get (pos + 1);

        return b1 * 256 + b2;

    }

    private int readU4 (int pos) {

        return readU2 (pos) * 256 * 256 + readU2 (pos + 2);

    }

    private static void writeU2 (byte[] arr, int pos, int value) {

        int v1 = (value & 0xff00) >> 8;

        int v2 = value & 0xff;

        if (v1 < 0) v1 += 256;

        if (v2 < 0) v2 += 256;

        arr[pos] = (byte)v1;

        arr[pos + 1] = (byte)v2;

    }

    private static void writeU4 (byte[] arr, int pos, int value) {

        writeU2 (arr, pos, (value & 0xff00) >> 16);

        writeU2 (arr, pos + 2, value & 0x00ff);

    }

    /** @param pos position to read from

     * @param cnt[0] index in the pool that we are now reading

     */

    private int constantPoolSize (int pos, int[] cnt) {

        switch (get (pos)) {

            case 7: // CONSTANT_Class 

            case 8: // CONSTANT_String 

                return 3;

            case 9: // CONSTANT_Fieldref 

            case 10: // CONSTANT_Methodref 

            case 11: // CONSTANT_InterfaceMethodref 

            case 3: // CONSTANT_Integer

            case 4: // CONSTANT_Float

            case 12: // CONSTANT_NameAndType

                return 5;

            case 5: // CONSTANT_Long

            case 6: // CONSTANT_Double

                // after long and double the next entry in CP is unusable

                cnt[0]++;

                return 9;

            case 1: // CONSTANT_Utf8

                int len = readU2 (pos + 1);

                if (BYTE_SUPERCLASS.length == len) {

                    int base = pos + 3;

                    // we are searching for an attribute with given name

                    for (int i = 0; i < BYTE_SUPERCLASS.length; i++) {

                        if (BYTE_SUPERCLASS[i] != arr[base + i]) {

                            // regular exit

                            return len + 3;

                        }

                    }

                    // we have found the attribute

                    if (superClassNameIndex != 0) {

                        throw new IllegalStateException (ATTR_SUPERCLASS + " registered for the second time!"); // NOI18N

                    }

                    superClassNameIndex = cnt[0];

                }

                // ok, exit

                return len + 3;

            default:

                throw new IllegalStateException ("Unknown pool type: " + get (pos)); // NOI18N

        }

    }

    private int fieldSize (int pos) {

        int s = 8;

        int cnt = readU2 (pos + 6);

        while (cnt-- > 0) {

            s += attributeSize (pos + s);

        }

        return s;

    }

    private int methodSize (int pos) {

        return fieldSize (pos);

    }

    private int attributeSize (int pos) {

        if (superClassNameIndex > 0) {

            // index to the name attr

            int name = readU2 (pos);

            if (name == superClassNameIndex) {

                if (superClassNameAttr > 0) {

                    throw new IllegalStateException ("Two attributes with name " + ATTR_SUPERCLASS); // NOI18N

                }

                // we found the attribute

                superClassNameAttr = pos;

            }

        }

        int len = readU4 (pos + 2);

        return len + 6;

    }

}

/*

 *                 Sun Public License Notice

 * 

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 * 

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2002 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans;

import java.util.*;

import java.net.URL;

import java.io.IOException;

/**

 * A class loader that has multiple parents and uses them for loading

 * classes and resources. It can be used in tree hierarchy, where it

 * can exploit its capability to not throw ClassNotFoundException when

 * communicating with other ProxyClassLoader.

 * It itself doesn't load classes or resources, but allows subclasses

 * to add such functionality.

 *

 * @author  Petr Nejedly, Jesse Glick

 */

public class ProxyClassLoader extends ClassLoader {

    /** empty enumeration */

    private static final Enumeration EMPTY = new ArrayEnumeration (new Object[0]);

    // Map<String,ClassLoader>

    // packages are given in format "org/netbeans/modules/foo/"

    private final Map domainsByPackage = new HashMap(); 

    // Map<String,Package>

    private HashMap packages = new HashMap();

    // All parentf of this classloader, including their parents recursively

    private ClassLoader[] parents;

    /** if true, we have been destroyed */

    private boolean dead = false;

    /** Create a multi-parented classloader.

     * @param parents list of parent classloaders. 

     * @throws IllegalArgumentException if there are any nulls or duplicate

     * parent loaders or cycles.

     */

    public ProxyClassLoader( ClassLoader[] parents ) {

        if (parents.length == 0) {

            throw new IllegalArgumentException ("ProxyClassLoader must have a parent"); // NOI18N

        }

        Set check = new HashSet(Arrays.asList(parents)); // Set<ClassLoader>

        if (check.size() < parents.length) throw new IllegalArgumentException("duplicate parents"); // NOI18N

        if (check.contains(null)) throw new IllegalArgumentException("null parent"); // NOI18N

        this.parents = coalesceParents(parents);

    }

    // this is used only by system classloader, maybe we can redesign it a bit

    // to live without this functionality, then destroy may also go away

    /** Add new parents dynamically.

     * @param parents the new parents to add (append to list)

     * @throws IllegalArgumentException in case of a null or cyclic parent (duplicate OK)

     */

    public synchronized void append(ClassLoader[] nueparents) throws IllegalArgumentException {

        // XXX should this be synchronized?

        if (nueparents == null) throw new IllegalArgumentException("null parents array"); // NOI18N

        for (int i = 0; i < nueparents.length; i++) {

            if (nueparents[i] == null) throw new IllegalArgumentException("null parent"); // NOI18N

        }

        parents = coalesceAppend(parents, nueparents);

    }

    /** Try to destroy this classloader.

     * Subsequent attempts to use it will log an error (at most one though).

     */

    public void destroy() {

        dead = true;

    }

    private void zombieCheck(String hint) {

        if (dead) {

            IllegalStateException ise = new IllegalStateException("WARNING - attempting to use a zombie classloader " + this + " on " + hint + ". This means classes from a disabled module are still active. May or may not be a problem."); // NOI18N

            JarClassLoader.notify(0, ise);

            // don't warn again for same loader... this was enough

            dead = false;

        }

    }

    /**

     * Loads the class with the specified name.  The implementation of

     * this method searches for classes in the following order:<p>

     * <ol>

     * <li> Calls {@link #findLoadedClass(String)} to check if the class has

     *      already been loaded.

     * <li> Checks the caches whether another class from the same package

     *      was already loaded and uses the same classloader

     * <li> Tries to find the class using parent loaders in their order.

     * <li> Calls the {@link #simpleFindClass(String,String)} method to find

     *      the class using this class loader.

     * </ol>

     *

     * @param     name the name of the class

     * @param     resolve if <code>true</code> then resolve the class

     * @return	  the resulting <code>Class</code> object

     * @exception ClassNotFoundException if the class could not be found

     */

    protected synchronized final Class loadClass(String name, boolean resolve)

                                            throws ClassNotFoundException {

        zombieCheck(name);

        // XXX this section is a candidate for local optimization:

        String filename = name.replace('.', '/').concat(".class"); // NOI18N

        int idx = filename.lastIndexOf('/'); // NOI18N

        if (idx == -1) throw new ClassNotFoundException("Will not load classes from default package"); // NOI18N

        String pkg = filename.substring(0, idx + 1); // "org/netbeans/modules/foo/"

        Class c = smartLoadClass(name, filename, pkg);

        if(c == null) throw new ClassNotFoundException(name);

        if (resolve) resolveClass(c);

        return c;

    }

    /** This ClassLoader can't load anything itself. Subclasses

     * may override this method to do some class loading themselves. The

     * implementation should not throw any exception, just return

     * <CODE>null</CODE> if it can't load required class.

     *

     * @param  name the name of the class

     * @param  fileName the expected filename of the classfile, like

     *      <CODE>java/lang/Object.class</CODE> for <CODE>java.lang.Object</CODE>

     *      The ClassLoader implementation may or may not use it, depending

     *      whether it is usefull to it.

     * @return the resulting <code>Class</code> object or <code>null</code>

     */

    protected Class simpleFindClass(String name, String fileName) {

        return null;

    }

    /**

     * Finds the resource with the given name. The implementation of

     * this method searches for resources in the following order:<p>

     * <ol>

     * <li> Checks the caches whether another resource or class from the same

     *      package was already loaded and uses the same classloader.

     * <li> Tries to find the resources using parent loaders in their order.

     * <li> Calls the {@link #findResource(String)} method to find

     *      the resources using this class loader.

     * </ol>

     *

     * @param  name a "/"-separated path name that identifies the resource.

     * @return a URL for reading the resource, or <code>null</code> if

     *      the resource could not be found.

     * @see #findResource(String)

     */

    public final URL getResource(final String name) {

        zombieCheck(name);

        final int slashIdx = name.lastIndexOf('/');

        if (slashIdx == -1) return null;    // won't load from the default package

        final String pkg = name.substring(0, slashIdx + 1);

        if (isSpecialResource(pkg)) {

            // Disable domain cache for this one, do a simple check.

            for (int i = 0; i < parents.length; i++) {

                if (!shouldDelegateResource(pkg, parents[i])) continue;

                URL u;

                if (parents[i] instanceof ProxyClassLoader) {

                    u = ((ProxyClassLoader)parents[i]).findResource(name);

                } else {

                    u = parents[i].getResource(name);

                }

                if (u != null) return u;

            }

            return findResource(name);

        }

        ClassLoader owner = (ClassLoader)domainsByPackage.get(pkg);

        if (owner != null) { // known package

            // Note that shouldDelegateResource should already be true for this!

            if (owner instanceof ProxyClassLoader) {

                return ((ProxyClassLoader)owner).findResource(name); // we have its parents, skip them

	    } else {

                return owner.getResource(name);     // know nothing about this loader and his structure

            }

        } 

        // virgin package

        URL retVal = null;

        for (int i = 0; i < parents.length; i++) {

            owner = parents[i];

            if (!shouldDelegateResource(pkg, owner)) continue;

            if (owner instanceof ProxyClassLoader) {

                retVal = ((ProxyClassLoader)owner).findResource(name); // skip parents (checked already)

            } else {

                retVal = owner.getResource(name); // know nothing about this loader and his structure

            }

            if (retVal != null) {

                domainsByPackage.put(pkg, owner);

                return retVal;

            }

        }

        // try it ourself

        retVal = findResource(name);

        if (retVal != null) {

            domainsByPackage.put(pkg, this);

        }

        return retVal;

    }

    /** This ClassLoader can't load anything itself. Subclasses

     * may override this method to do some resource loading themselves.

     *

     * @param  name the resource name

     * @return a URL for reading the resource, or <code>null</code>

     *      if the resource could not be found.

     */

    protected URL findResource(String name) {

	return null;

    }

    /**

     * Finds all the resource with the given name. The implementation of

     * this method uses the {@link #simpleFindResources(String)} method to find

     * all the resources available from this classloader and adds all the 

     * resources from all the parents.

     *

     * @param  name the resource name

     * @return an Enumeration of URLs for the resources

     * @throws IOException if I/O errors occur

     */    

    protected final synchronized Enumeration findResources(String name) throws IOException {

        zombieCheck(name);

        final int slashIdx = name.lastIndexOf('/');

        if (slashIdx == -1) return EMPTY; // won't load from the default package

        final String pkg = name.substring(0, slashIdx + 1);

        // Don't bother optimizing this call by domains.

        // It is mostly used for resources for which isSpecialResource would be true anyway.

        Enumeration[] es = new Enumeration[parents.length + 1];

        for (int i = 0; i < parents.length; i++) {

            if (!shouldDelegateResource(pkg, parents[i])) {

                es[i] = EMPTY;

                continue;

            }

            if (parents[i] instanceof ProxyClassLoader) {

                es[i] = ((ProxyClassLoader)parents[i]).simpleFindResources(name);

            } else {

                es[i] = parents[i].getResources(name);

            }

        }

        es[parents.length] = simpleFindResources(name);

        // Should not be duplicates, assuming the parent loaders are properly distinct

        // from one another and do not overlap in JAR usage, which they ought not.

        // Anyway MetaInfServicesLookup, the most important client of this method, does

        // its own duplicate filtering already.

        return new AAEnum (es);

    }

    /** This ClassLoader can't load anything itself. Subclasses

     * may override this method to do some resource loading themselves, this

     * implementation simply delegates to findResources method of the superclass

     * that should return empty Enumeration.

     *

     * @param  name the resource name

     * @return an Enumeration of URLs for the resources

     * @throws IOException if I/O errors occur

     */

    protected Enumeration simpleFindResources(String name) throws IOException {

        return super.findResources(name);

    }

    /**

     * Returns a Package that has been defined by this class loader or any

     * of its parents.

     *

     * @param  name the package name

     * @return the Package corresponding to the given name, or null if not found

     */

    protected Package getPackage(String name) {

        zombieCheck(name);

        int idx = name.lastIndexOf('.');

        if (idx == -1) return null;

        String spkg = name.substring(0, idx + 1).replace('.', '/');

	synchronized (packages) {

	    Package pkg = (Package)packages.get(name);

            if (pkg != null) return pkg;

            for (int i = 0; i < parents.length; i++) {

                ClassLoader par = parents[i];

                if (par instanceof ProxyClassLoader && shouldDelegateResource(spkg, par)) {

                    pkg = ((ProxyClassLoader)par).getPackage(name);

                    if(pkg != null) break;

                }

            }

            // do our own lookup

            if (pkg == null) pkg = super.getPackage(name);

            // cache results

            if (pkg != null) packages.put(name, pkg);

            return pkg;

	}

    }

    /** This is here just for locking serialization purposes.

     * Delegates to super.definePackage with proper locking.

     */

    protected Package definePackage(String name, String specTitle,

                String specVersion, String specVendor, String implTitle,

		String implVersion, String implVendor, URL sealBase )

		throws IllegalArgumentException {

	synchronized (packages) {

	    return super.definePackage (name, specTitle, specVersion, specVendor, implTitle,

			implVersion, implVendor, sealBase);

	}

    }

    /**

     * Returns all of the Packages defined by this class loader and its parents.

     *

     * @return the array of <code>Package</code> objects defined by this

     * <code>ClassLoader</code>

     */

    protected synchronized Package[] getPackages() {

        zombieCheck(null);

        Map all = new HashMap(); // Map<String,Package>

        addPackages(all, super.getPackages());

        for (int i = 0; i < parents.length; i++) {

            ClassLoader par = parents[i];

            if (par instanceof ProxyClassLoader) {

                // XXX should ideally use shouldDelegateResource here...

                addPackages(all, ((ProxyClassLoader)par).getPackages());

            }

        }

        synchronized (packages) {

            Iterator it = all.entrySet().iterator();

            while (it.hasNext()) {

                Map.Entry entry = (Map.Entry)it.next();

                Object name = entry.getKey();

                if (! packages.containsKey(name)) {

                    packages.put(name, entry.getValue());

                }

            }

        }

        return (Package[])all.values().toArray(new Package[all.size()]);

    }

    public Package getPackageAccessibly(String name) {

        return getPackage(name);

    }

    public Package[] getPackagesAccessibly() {

        return getPackages();

    }

    /** Coalesce parent classloaders into an optimized set.

     * This means that all parents of the specified classloaders

     * are also added recursively, removing duplicates along the way.

     * Search order should be preserved (parents before children, stable w.r.t. inputs).

     * @param loaders list of suggested parents (no nulls or duplicates permitted)

     * @return optimized list of parents (no nulls or duplicates)

     * @throws IllegalArgumentException if there are cycles

     */

    private ClassLoader[] coalesceParents(ClassLoader[] loaders) throws IllegalArgumentException {

        int likelySize = loaders.length * 3 + 1;

        Set resultingUnique = new HashSet(likelySize); // Set<ClassLoader>

        List resulting = new ArrayList(likelySize); // List<ClassLoader>

        for (int i = 0; i < loaders.length; i++) {

            addRec(resultingUnique, resulting, loaders[i]);

        }

        ClassLoader[] ret = (ClassLoader[])resulting.toArray(new ClassLoader[resulting.size()]);

        return ret;

    }

    /** Coalesce a new set of loaders into the existing ones.

     */

    private ClassLoader[] coalesceAppend(ClassLoader[] existing, ClassLoader[] appended) throws IllegalArgumentException {

        int likelySize = existing.length + 3;

        Set resultingUnique = new HashSet(likelySize);

        List existingL = Arrays.asList(existing);

        resultingUnique.addAll(existingL);

        if (resultingUnique.containsAll(Arrays.asList(appended))) {

            // No change required.

            return existing;

        }

        List resulting = new ArrayList(likelySize);

        resulting.addAll(existingL);

        int fromIdx = resulting.size();

        for (int i = 0; i < appended.length; i++) {

            addRec(resultingUnique, resulting, appended[i]);

        }

        ClassLoader[] ret = (ClassLoader[])resulting.toArray(new ClassLoader[resulting.size()]);

        return ret;

    }

    private void addRec(Set resultingUnique, List resulting, ClassLoader loader) throws IllegalArgumentException {

        if (loader == this) throw new IllegalArgumentException("cycle in parents"); // NOI18N

        if (resultingUnique.contains(loader)) return;

        if (loader instanceof ProxyClassLoader) {

            ClassLoader[] parents = ((ProxyClassLoader)loader).parents;

            for (int i = 0; i < parents.length; i++) {

                addRec(resultingUnique, resulting, parents[i]);

            }

        }

        resultingUnique.add(loader);

        resulting.add(loader);

    }

    /** A method that finds a class either in itself or in parents.

     * It uses dual signaling for class not found: it can either return null

     * or throw CNFE itself.

     * @param name class name, e.g. "org.netbeans.modules.foo.Clazz"

     * @param fileName resource name, e.g. "org/netbeans/modules/foo/Clazz.class"

     * @param pkg package component, e.g. "org/netbeans/modules/foo/"

     * @return a class or null if not found. It can also throw an exception.

     * @throws ClassNotFoundException in case it doesn't found a class

     * and a parent eglible for loading it thrown it already.

     */

    private final Class smartLoadClass(String name, String fileName, String pkg) throws ClassNotFoundException {

	// First, check if the class has already been loaded

	Class c = findLoadedClass(name);

	if(c != null) return c;

        final ClassLoader owner = isSpecialResource(pkg) ? null : (ClassLoader)domainsByPackage.get(pkg);

        if (owner == this) {

            return simpleFindClass(name,fileName);

        }

        if (owner != null) {

            // Note that shouldDelegateResource should already be true as we hit this pkg before.

            if (owner instanceof ProxyClassLoader) {

                return ((ProxyClassLoader)owner).fullFindClass(name,fileName);

            } else {

                return owner.loadClass(name); // May throw CNFE, will be propagated

            }

        }

        // Virgin package, do the parent scan 

        c = loadInOrder(name, fileName, pkg);

        if (c != null) {

            final ClassLoader owner2 = c.getClassLoader(); // who got it?

            domainsByPackage.put(pkg, owner2);

        }

        return c;

    }

    private final Class loadInOrder( String name, String fileName, String pkg ) throws ClassNotFoundException {

        ClassNotFoundException cached = null;

        for (int i = 0; i < parents.length; i++) {

	    ClassLoader par = parents[i];

            if (!shouldDelegateResource(pkg, par)) continue;

	    if (par instanceof ProxyClassLoader) {

		Class c = ((ProxyClassLoader)par).fullFindClass(name,fileName);

                if (c != null) return c;

	    } else {

		try {

		    return par.loadClass(name);

		} catch( ClassNotFoundException cnfe ) {

                    cached = cnfe;

                }

	    }

	}

        Class c = simpleFindClass(name,fileName); // Try it ourselves

        if (c != null) return c;

        if (cached != null) throw cached;

	return null;

    }

    private synchronized Class fullFindClass(String name, String fileName) {

	Class c = findLoadedClass(name);

	return (c == null) ? simpleFindClass(name, fileName) : c;

    }    

    private void addPackages(Map all, Package[] pkgs) {

        // Would be easier if Package.equals() was just defined sensibly...

        for (int i = 0; i < pkgs.length; i++) {

            all.put(pkgs[i].getName(), pkgs[i]);

        }

    }

    /** Test whether a given resource name is something that any JAR might

     * have, and for which the domain cache should be disabled.

     * The result must not change from one call to the next with the same argument.

     * By default the domain cache is disabled only for META-INF/* JAR information.

     * @param pkg the package component of the resource path ending with a slash,

     *        e.g. "org/netbeans/modules/foo/"

     * @return true if it is a special resource, false for normal domain-cached resource

     * @since org.netbeans.core/1 1.3

     */

    protected boolean isSpecialResource(String pkg) {

        if (pkg.startsWith("META-INF/")) return true; // NOI18N

        return false;

    }

    /** Test whether a given resource request (for a class or not) should be

     * searched for in the specified parent classloader or not.

     * The result must not change from one call to the next with the same arguments.

     * By default, always true. Subclasses may override to "mask" certain

     * packages from view, possibly according to the classloader chain.

     * @param pkg the package component of the resource path ending with a slash,

     *        e.g. "org/netbeans/modules/foo/"

     * @param parent a classloader which is a direct or indirect parent of this one

     * @return true if the request should be delegated to this parent; false to

     *         only search elsewhere (other parents, this loader's own namespace)

     * @since org.netbeans.core/1 1.3

     */

    protected boolean shouldDelegateResource(String pkg, ClassLoader parent) {

        return true;

    }

    private static final class ArrayEnumeration implements Enumeration {

        /** The array */

        private Object[] array;

        /** Current index in the array */

        private int index = 0;

        /** Constructs a new ArrayEnumeration for specified array */

        public ArrayEnumeration (Object[] array) {

            this.array = array;

        }

        /** Tests if this enumeration contains more elements.

        * @return  <code>true</code> if this enumeration contains more elements;

        *          <code>false</code> otherwise.

        */

        public boolean hasMoreElements() {

            return (index < array.length);

        }

        /** Returns the next element of this enumeration.

        * @return     the next element of this enumeration.

        * @exception  NoSuchElementException  if no more elements exist.

        */

        public Object nextElement() {

            try {

                return array[index++];

            } catch (ArrayIndexOutOfBoundsException e) {

                throw new NoSuchElementException();

            }

        }

    }

    private static final class AAEnum implements Enumeration {

        /** The array */

        private Enumeration[] array;

        /** Current index in the array */

        private int index = 0;

        /** Constructs a new ArrayEnumeration for specified array */

        public AAEnum (Enumeration[] array) {

            this.array = array;

        }

        /** Tests if this enumeration contains more elements.

        * @return  <code>true</code> if this enumeration contains more elements;

        *          <code>false</code> otherwise.

        */

        public boolean hasMoreElements() {

            for (;;) {

                if (index == array.length) {

                    return false;

                }

                if (array[index].hasMoreElements ()) {

                    return true;

                }

                index++;

            }

        }

        /** Returns the next element of this enumeration.

        * @return     the next element of this enumeration.

        * @exception  NoSuchElementException  if no more elements exist.

        */

        public Object nextElement() {

            try {

                return array[index].nextElement ();

            } catch (NoSuchElementException ex) {

                if (hasMoreElements ()) {

                    // try once more

                    return nextElement ();

                }

                throw ex;

            } catch (ArrayIndexOutOfBoundsException e) {

                throw new NoSuchElementException();

            }

        }

    }

}