/*

 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package jdk.nashorn.internal.runtime.linker;

import static jdk.internal.org.objectweb.asm.Opcodes.ACC_FINAL;

import static jdk.internal.org.objectweb.asm.Opcodes.ACC_PRIVATE;

import static jdk.internal.org.objectweb.asm.Opcodes.ACC_PUBLIC;

import static jdk.internal.org.objectweb.asm.Opcodes.ACC_STATIC;

import static jdk.internal.org.objectweb.asm.Opcodes.ACC_SUPER;

import static jdk.internal.org.objectweb.asm.Opcodes.ACC_VARARGS;

import static jdk.internal.org.objectweb.asm.Opcodes.ACONST_NULL;

import static jdk.internal.org.objectweb.asm.Opcodes.ALOAD;

import static jdk.internal.org.objectweb.asm.Opcodes.ARETURN;

import static jdk.internal.org.objectweb.asm.Opcodes.ASTORE;

import static jdk.internal.org.objectweb.asm.Opcodes.DUP;

import static jdk.internal.org.objectweb.asm.Opcodes.IFNONNULL;

import static jdk.internal.org.objectweb.asm.Opcodes.ILOAD;

import static jdk.internal.org.objectweb.asm.Opcodes.ISTORE;

import static jdk.internal.org.objectweb.asm.Opcodes.RETURN;

import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;

import static jdk.nashorn.internal.lookup.Lookup.MH;

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodType;

import java.lang.reflect.Constructor;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.security.AccessController;

import java.security.AllPermission;

import java.security.CodeSigner;

import java.security.CodeSource;

import java.security.Permissions;

import java.security.PrivilegedAction;

import java.security.ProtectionDomain;

import java.security.SecureClassLoader;

import java.security.SecureRandom;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.Random;

import java.util.Set;

import jdk.internal.dynalink.beans.StaticClass;

import jdk.internal.dynalink.support.LinkRequestImpl;

import jdk.internal.org.objectweb.asm.ClassWriter;

import jdk.internal.org.objectweb.asm.Label;

import jdk.internal.org.objectweb.asm.Opcodes;

import jdk.internal.org.objectweb.asm.Type;

import jdk.internal.org.objectweb.asm.commons.InstructionAdapter;

import jdk.nashorn.internal.objects.NativeJava;

import jdk.nashorn.internal.runtime.Context;

import jdk.nashorn.internal.runtime.ECMAErrors;

import jdk.nashorn.internal.runtime.ECMAException;

import jdk.nashorn.internal.runtime.ScriptFunction;

import jdk.nashorn.internal.runtime.ScriptObject;

import jdk.nashorn.internal.runtime.ScriptRuntime;

import jdk.nashorn.internal.runtime.Undefined;

/**

 * <p>A factory class that generates adapter classes. Adapter classes allow implementation of Java interfaces and

 * extending of Java classes from JavaScript. For every combination of a superclass to extend and interfaces to

 * implement (collectively: "original types"), exactly one adapter class is generated that extends the specified

 * superclass and implements the specified interfaces.

 * </p><p>

 * The adapter class is generated in a new secure class loader that inherits Nashorn's protection domain, and has either

 * one of the original types' class loader or the Nashorn's class loader as its parent - the parent class loader

 * is chosen so that all the original types and the Nashorn core classes are visible from it (as the adapter will have

 * constant pool references to ScriptObject and ScriptFunction classes). In case none of the candidate class loaders has

 * visibility of all the required types, an error is thrown.

 * </p><p>

 * For every protected or public constructor in the extended class, the adapter class will have one or two public

 * constructors (visibility of protected constructors in the extended class is promoted to public). In every case, for

 * every original constructor, a new constructor taking a trailing ScriptObject argument preceded by original

 * constructor arguments is present on the adapter class. When such a constructor is invoked, the passed ScriptObject's

 * member functions are used to implement and/or override methods on the original class, dispatched by name. A single

 * JavaScript function will act as the implementation for all overloaded methods of the same name. When methods on an

 * adapter instance are invoked, the functions are invoked having the ScriptObject passed in the instance constructor as

 * their "this". Subsequent changes to the ScriptObject (reassignment or removal of its functions) are not reflected in

 * the adapter instance; the method implementations are bound to functions at constructor invocation time.

 * {@code java.lang.Object} methods {@code equals}, {@code hashCode}, and {@code toString} can also be overridden. The

 * only restriction is that since every JavaScript object already has a {@code toString} function through the

 * {@code Object.prototype}, the {@code toString} in the adapter is only overridden if the passed ScriptObject has a

 * {@code toString} function as its own property, and not inherited from a prototype. All other adapter methods can be

 * implemented or overridden through a prototype-inherited function of the ScriptObject passed to the constructor too.

 * </p><p>

 * If the original types collectively have only one abstract method, or have several of them, but all share the

 * same name, an additional constructor is provided for every original constructor; this one takes a ScriptFunction as

 * its last argument preceded by original constructor arguments. This constructor will use the passed function as the

 * implementation for all abstract methods. For consistency, any concrete methods sharing the single abstract method

 * name will also be overridden by the function. When methods on the adapter instance are invoked, the ScriptFunction is

 * invoked with {@code null} as its "this".

 * </p><p>

 * For adapter methods that return values, all the JavaScript-to-Java conversions supported by Nashorn will be in effect

 * to coerce the JavaScript function return value to the expected Java return type.

 * </p><p>

 * Since we are adding a trailing argument to the generated constructors in the adapter class, they will never be

 * declared as variable arity, even if the original constructor in the superclass was declared as variable arity. The

 * reason we are passing the additional argument at the end of the argument list instead at the front is that the

 * source-level script expression <code>new X(a, b) { ... }</code> (which is a proprietary syntax extension Nashorn uses

 * to resemble Java anonymous classes) is actually equivalent to <code>new X(a, b, { ... })</code>.

 * </p><p>

 * You normally don't use this class directly, but rather either create adapters from script using

 * {@link NativeJava#extend(Object, Object...)}, using the {@code new} operator on abstract classes and interfaces (see

 * {@link NativeJava#type(Object, Object)}), or implicitly when passing script functions to Java methods expecting SAM

 * types.

 * </p>

 */

public final class JavaAdapterFactory {

    private static final Type SCRIPT_FUNCTION_TYPE = Type.getType(ScriptFunction.class);

    private static final Type SCRIPT_OBJECT_TYPE = Type.getType(ScriptObject.class);

    private static final Type OBJECT_TYPE = Type.getType(Object.class);

    private static final Type STRING_TYPE = Type.getType(String.class);

    private static final Type CONTEXT_TYPE = Type.getType(Context.class);

    private static final Type METHOD_TYPE_TYPE = Type.getType(MethodType.class);

    private static final Type METHOD_HANDLE_TYPE = Type.getType(MethodHandle.class);

    private static final String GET_HANDLE_OBJECT_DESCRIPTOR = Type.getMethodDescriptor(METHOD_HANDLE_TYPE,

            OBJECT_TYPE, STRING_TYPE, METHOD_TYPE_TYPE, Type.BOOLEAN_TYPE);

    private static final String GET_HANDLE_FUNCTION_DESCRIPTOR = Type.getMethodDescriptor(METHOD_HANDLE_TYPE,

            SCRIPT_FUNCTION_TYPE, METHOD_TYPE_TYPE, Type.BOOLEAN_TYPE);

    private static final Type RUNTIME_EXCEPTION_TYPE = Type.getType(RuntimeException.class);

    private static final Type THROWABLE_TYPE = Type.getType(Throwable.class);

    private static final Type PRIVILEGED_ACTION_TYPE = Type.getType(PrivilegedAction.class);

    private static final Type UNSUPPORTED_OPERATION_TYPE = Type.getType(UnsupportedOperationException.class);

    private static final String THIS_CLASS_TYPE_NAME = Type.getInternalName(JavaAdapterFactory.class);

    private static final String RUNTIME_EXCEPTION_TYPE_NAME = RUNTIME_EXCEPTION_TYPE.getInternalName();

    private static final String ERROR_TYPE_NAME = Type.getInternalName(Error.class);

    private static final String THROWABLE_TYPE_NAME = THROWABLE_TYPE.getInternalName();

    private static final String CONTEXT_TYPE_NAME = CONTEXT_TYPE.getInternalName();

    private static final String OBJECT_TYPE_NAME = OBJECT_TYPE.getInternalName();

    private static final String PRIVILEGED_ACTION_TYPE_NAME = PRIVILEGED_ACTION_TYPE.getInternalName();

    private static final String UNSUPPORTED_OPERATION_TYPE_NAME = UNSUPPORTED_OPERATION_TYPE.getInternalName();

    private static final String METHOD_HANDLE_TYPE_DESCRIPTOR = METHOD_HANDLE_TYPE.getDescriptor();

    private static final String SCRIPT_OBJECT_TYPE_DESCRIPTOR = SCRIPT_OBJECT_TYPE.getDescriptor();

    private static final String GET_GLOBAL_METHOD_DESCRIPTOR = Type.getMethodDescriptor(SCRIPT_OBJECT_TYPE);

    private static final String SET_GLOBAL_METHOD_DESCRIPTOR = Type.getMethodDescriptor(Type.VOID_TYPE, SCRIPT_OBJECT_TYPE);

    private static final String GET_CLASS_METHOD_DESCRIPTOR = Type.getMethodDescriptor(Type.getType(Class.class));

    private static final String PRIVILEGED_RUN_METHOD_DESCRIPTOR = Type.getMethodDescriptor(OBJECT_TYPE);

    // Package used when the adapter can't be defined in the adaptee's package (either because it's sealed, or because

    // it's a java.* package.

    private static final String ADAPTER_PACKAGE_PREFIX = "jdk/nashorn/internal/javaadapters/";

    // Class name suffix used to append to the adaptee class name, when it can be defined in the adaptee's package.

    private static final String ADAPTER_CLASS_NAME_SUFFIX = "$$NashornJavaAdapter";

    private static final String JAVA_PACKAGE_PREFIX = "java/";

    private static final int MAX_GENERATED_TYPE_NAME_LENGTH = 238; //255 - 17; 17 is the maximum possible length for the global setter inner class suffix

    private static final String INIT = "<init>";

    private static final String VOID_NOARG = Type.getMethodDescriptor(Type.VOID_TYPE);

    private static final String GLOBAL_FIELD_NAME = "global";

    /**

     * Contains various outcomes for attempting to generate an adapter class. These are stored in AdapterInfo instances.

     * We have a successful outcome (adapter class was generated) and four possible error outcomes: superclass is final,

     * superclass is not public, superclass has no public or protected constructor, more than one superclass was

     * specified. We don't throw exceptions when we try to generate the adapter, but rather just record these error

     * conditions as they are still useful as partial outcomes, as Nashorn's linker can still successfully check whether

     * the class can be autoconverted from a script function even when it is not possible to generate an adapter for it.

     */

    private enum AdaptationOutcome {

        SUCCESS,

        ERROR_FINAL_CLASS,

        ERROR_NON_PUBLIC_CLASS,

        ERROR_NO_ACCESSIBLE_CONSTRUCTOR,

        ERROR_MULTIPLE_SUPERCLASSES,

        ERROR_NO_COMMON_LOADER

    }

    /**

     * Collection of methods we never override: Object.clone(), Object.finalize().

     */

    private static final Collection<MethodInfo> EXCLUDED = getExcludedMethods();

    /**

     * A mapping from an original Class object to AdapterInfo representing the adapter for the class it represents.

     */

    private static final ClassValue<Map<List<Class<?>>, AdapterInfo>> ADAPTER_INFO_MAPS = new ClassValue<Map<List<Class<?>>, AdapterInfo>>() {

        @Override

        protected Map<List<Class<?>>, AdapterInfo> computeValue(final Class<?> type) {

            return new HashMap<>();

        }

    };

    private static final Random random = new SecureRandom();

    private static final ProtectionDomain GENERATED_PROTECTION_DOMAIN = createGeneratedProtectionDomain();

    // This is the superclass for our generated adapter.

    private final Class<?> superClass;

    // Class loader used as the parent for the class loader we'll create to load the generated class. It will be a class

    // loader that has the visibility of all original types (class to extend and interfaces to implement) and of the

    // Nashorn classes.

    private final ClassLoader commonLoader;

    // Binary name of the superClass

    private final String superClassName;

    // Binary name of the generated class.

    private final String generatedClassName;

    // Binary name of the PrivilegedAction inner class that is used to

    private final String globalSetterClassName;

    private final Set<String> usedFieldNames = new HashSet<>();

    private final Set<String> abstractMethodNames = new HashSet<>();

    private final String samName;

    private final Set<MethodInfo> finalMethods = new HashSet<>(EXCLUDED);

    private final Set<MethodInfo> methodInfos = new HashSet<>();

    private boolean autoConvertibleFromFunction = false;

    private final ClassWriter cw;

    /**

     * Creates a factory that will produce the adapter type for the specified original type.

     * @param originalType the type for which this factory will generate the adapter type.

     * @param definingClassAndLoader the class in whose ClassValue we'll store the generated adapter, and its class loader.

     * @throws AdaptationException if the adapter can not be generated for some reason.

     */

    private JavaAdapterFactory(final Class<?> superType, final List<Class<?>> interfaces, final ClassAndLoader definingClassAndLoader) throws AdaptationException {

        assert superType != null && !superType.isInterface();

        assert interfaces != null;

        assert definingClassAndLoader != null;

        this.superClass = superType;

        this.commonLoader = findCommonLoader(definingClassAndLoader);

        cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS) {

            @Override

            protected String getCommonSuperClass(final String type1, final String type2) {

                // We need to override ClassWriter.getCommonSuperClass to use this factory's commonLoader as a class

                // loader to find the common superclass of two types when needed.

                return JavaAdapterFactory.this.getCommonSuperClass(type1, type2);

            }

        };

        superClassName = Type.getInternalName(superType);

        generatedClassName = getGeneratedClassName(superType, interfaces);

        // Randomize the name of the privileged global setter, to make it non-feasible to find.

        final long l;

        synchronized(random) {

            l = random.nextLong();

        }

        // NOTE: they way this class name is calculated affects the value of MAX_GENERATED_TYPE_NAME_LENGTH constant. If

        // you change the calculation of globalSetterClassName, adjust the constant too.

        globalSetterClassName = generatedClassName.concat("$" + Long.toHexString(l & Long.MAX_VALUE));

        cw.visit(Opcodes.V1_7, ACC_PUBLIC | ACC_SUPER | ACC_FINAL, generatedClassName, null, superClassName, getInternalTypeNames(interfaces));

        cw.visitField(ACC_PRIVATE | ACC_FINAL, GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR, null, null).visitEnd();

        usedFieldNames.add(GLOBAL_FIELD_NAME);

        gatherMethods(superType);

        gatherMethods(interfaces);

        samName = abstractMethodNames.size() == 1 ? abstractMethodNames.iterator().next() : null;

        generateFields();

        generateConstructors();

        generateMethods();

        // }

        cw.visitEnd();

    }

    private static String getGeneratedClassName(final Class<?> superType, final List<Class<?>> interfaces) {

        // The class we use to primarily name our adapter is either the superclass, or if it is Object (meaning we're

        // just implementing interfaces or extending Object), then the first implemented interface or Object.

        final Class<?> namingType = superType == Object.class ? (interfaces.isEmpty()? Object.class : interfaces.get(0)) : superType;

        final Package pkg = namingType.getPackage();

        final String namingTypeName = Type.getInternalName(namingType);

        final StringBuilder buf = new StringBuilder();

        if (namingTypeName.startsWith(JAVA_PACKAGE_PREFIX) || pkg == null || pkg.isSealed()) {

            // Can't define new classes in java.* packages

            buf.append(ADAPTER_PACKAGE_PREFIX).append(namingTypeName);

        } else {

            buf.append(namingTypeName).append(ADAPTER_CLASS_NAME_SUFFIX);

        }

        final Iterator<Class<?>> it = interfaces.iterator();

        if(superType == Object.class && it.hasNext()) {

            it.next(); // Skip first interface, it was used to primarily name the adapter

        }

        // Append interface names to the adapter name

        while(it.hasNext()) {

            buf.append("$$").append(it.next().getSimpleName());

        }

        return buf.toString().substring(0, Math.min(MAX_GENERATED_TYPE_NAME_LENGTH, buf.length()));

    }

    /**

     * Given a list of class objects, return an array with their binary names. Used to generate the array of interface

     * names to implement.

     * @param classes the classes

     * @return an array of names

     */

    private static String[] getInternalTypeNames(final List<Class<?>> classes) {

        final int interfaceCount = classes.size();

        final String[] interfaceNames = new String[interfaceCount];

        for(int i = 0; i < interfaceCount; ++i) {

            interfaceNames[i] = Type.getInternalName(classes.get(i));

        }

        return interfaceNames;

    }

    /**

     * Utility method used by few other places in the code. Tests if the class has the abstract modifier and is not an

     * array class. For some reason, array classes have the abstract modifier set in HotSpot JVM, and we don't want to

     * treat array classes as abstract.

     * @param clazz the inspected class

     * @return true if the class is abstract and is not an array type.

     */

    static boolean isAbstractClass(final Class<?> clazz) {

        return Modifier.isAbstract(clazz.getModifiers()) && !clazz.isArray();

    }

    /**

     * Returns an adapter class for the specified original types. The adapter class extends/implements the original

     * class/interfaces.

     * @param types the original types. The caller must pass at least one Java type representing either a public

     * interface or a non-final public class with at least one public or protected constructor. If more than one type is

     * specified, at most one can be a class and the rest have to be interfaces. The class can be in any position in the

     * array. Invoking the method twice with exactly the same types in the same order will return the same adapter

     * class, any reordering of types or even addition or removal of redundant types (i.e. interfaces that other types

     * in the list already implement/extend, or {@code java.lang.Object} in a list of types consisting purely of

     * interfaces) will result in a different adapter class, even though those adapter classes are functionally

     * identical; we deliberately don't want to incur the additional processing cost of canonicalizing type lists.

     * @return an adapter class. See this class' documentation for details on the generated adapter class.

     * @throws ECMAException with a TypeError if the adapter class can not be generated because the original class is

     * final, non-public, or has no public or protected constructors.

     */

    public static StaticClass getAdapterClassFor(final Class<?>[] types) {

        assert types != null && types.length > 0;

        final AdapterInfo adapterInfo = getAdapterInfo(types);

        final StaticClass clazz = adapterInfo.adapterClass;

        if (clazz != null) {

            return clazz;

        }

        adapterInfo.adaptationOutcome.typeError();

        throw new AssertionError();

    }

    private static AdapterInfo getAdapterInfo(final Class<?>[] types) {

        final ClassAndLoader definingClassAndLoader = getDefiningClassAndLoader(types);

        final Map<List<Class<?>>, AdapterInfo> adapterInfoMap = ADAPTER_INFO_MAPS.get(definingClassAndLoader.clazz);

        final List<Class<?>> typeList = types.length == 1 ? getSingletonClassList(types[0]) : Arrays.asList(types.clone());

        AdapterInfo adapterInfo;

        synchronized(adapterInfoMap) {

            adapterInfo = adapterInfoMap.get(typeList);

            if(adapterInfo == null) {

                adapterInfo = createAdapterInfo(types, definingClassAndLoader);

                adapterInfoMap.put(typeList, adapterInfo);

            }

        }

        return adapterInfo;

    }

    @SuppressWarnings({ "unchecked", "rawtypes" })

    private static List<Class<?>> getSingletonClassList(final Class<?> clazz) {

        return (List)Collections.singletonList(clazz);

    }

    /**

     * Returns whether an instance of the specified class/interface can be generated from a ScriptFunction. Returns true

     * iff: the adapter for the class/interface can be created, it is abstract (this includes interfaces), it has at

     * least one abstract method, all the abstract methods share the same name, and it has a public or protected default

     * constructor. Note that invoking this class will most likely result in the adapter class being defined in the JVM

     * if it hasn't been already.

     * @param clazz the inspected class

     * @return true iff an instance of the specified class/interface can be generated from a ScriptFunction.

     */

    static boolean isAutoConvertibleFromFunction(final Class<?> clazz) {

        return getAdapterInfo(new Class<?>[] { clazz }).autoConvertibleFromFunction;

    }

    /**

     * Returns a method handle representing a constructor that takes a single argument of the source type (which,

     * really, should be one of {@link ScriptObject}, {@link ScriptFunction}, or {@link Object}, and returns an instance

     * of the adapter for the target type. Used to implement the function autoconverters as well as the Nashorn's

     * JSR-223 script engine's {@code getInterface()} method.

     * @param sourceType the source type; should be either {@link ScriptObject}, {@link ScriptFunction}, or

     * {@link Object}. In case of {@code Object}, it will return a method handle that dispatches to either the script

     * object or function constructor at invocation based on the actual argument.

     * @param targetType the target type, for which adapter instances will be created

     * @return the constructor method handle.

     * @throws Exception if anything goes wrong

     */

    public static MethodHandle getConstructor(final Class<?> sourceType, final Class<?> targetType) throws Exception {

        final StaticClass adapterClass = getAdapterClassFor(new Class<?>[] { targetType });

    }

    /**

     * Finishes the bytecode generation for the adapter class that was started in the constructor, and loads the

     * bytecode as a new class into the JVM.

     * @return the generated adapter class

     */

    private Class<?> generateClass() {

        final String binaryName = generatedClassName.replace('/', '.');

        try {

            return Class.forName(binaryName, true, createClassLoader(commonLoader, binaryName, cw.toByteArray(),

                    globalSetterClassName.replace('/', '.')));

        } catch (final ClassNotFoundException e) {

            throw new AssertionError(e); // cannot happen

        }

    }

    /**

     * Tells if the given Class is an adapter or support class

     * @param clazz Class object

     * @return true if the Class given is adapter or support class

     */

    public static boolean isAdapterClass(Class<?> clazz) {

        return clazz.getClassLoader() instanceof AdapterLoader;

    }

    private static class AdapterLoader extends SecureClassLoader {

        AdapterLoader(ClassLoader parent) {

            super(parent);

        }

    }

    // Creation of class loader is in a separate static method so that it doesn't retain a reference to the factory

    // instance. Note that the adapter class is created in the protection domain of the class/interface being

    // extended/implemented, and only the privileged global setter action class is generated in the protection domain

    // of Nashorn itself. Also note that the creation and loading of the global setter is deferred until it is

    // required by JVM linker, which will only happen on first invocation of any of the adapted method. We could defer

    // it even more by separating its invocation into a separate static method on the adapter class, but then someone

    // with ability to introspect on the class and use setAccessible(true) on it could invoke the method. It's a

    // security tradeoff...

    private static ClassLoader createClassLoader(final ClassLoader parentLoader, final String className,

            final byte[] classBytes, final String privilegedActionClassName) {

        return new AdapterLoader(parentLoader) {

            private final ProtectionDomain myProtectionDomain = getClass().getProtectionDomain();

            @Override

            protected Class<?> findClass(final String name) throws ClassNotFoundException {

                if(name.equals(className)) {

                    final byte[] bytes = classBytes;

                    return defineClass(name, bytes, 0, bytes.length, GENERATED_PROTECTION_DOMAIN);

                } else if(name.equals(privilegedActionClassName)) {

                    final byte[] bytes = generatePrivilegedActionClassBytes(privilegedActionClassName.replace('.', '/'));

                    return defineClass(name, bytes, 0, bytes.length, myProtectionDomain);

                } else {

                    throw new ClassNotFoundException(name);

                }

            }

        };

    }

    /**

     * Generates a PrivilegedAction implementation class for invoking {@link Context#setGlobal(ScriptObject)} from the

     * adapter class.

     */

    private static byte[] generatePrivilegedActionClassBytes(final String className) {

        final ClassWriter w = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);

        // class GlobalSetter implements PrivilegedAction {

        w.visit(Opcodes.V1_7, ACC_SUPER | ACC_FINAL, className, null, OBJECT_TYPE_NAME, new String[] {

                PRIVILEGED_ACTION_TYPE_NAME

        });