<?xml version="1.0" encoding="UTF-8"?>

<!--

DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.

Oracle and Java are registered trademarks of Oracle and/or its affiliates.

Other names may be trademarks of their respective owners.

The contents of this file are subject to the terms of either the GNU

General Public License Version 2 only ("GPL") or the Common

Development and Distribution License("CDDL") (collectively, the

"License"). You may not use this file except in compliance with the

License. You can obtain a copy of the License at

http://www.netbeans.org/cddl-gplv2.html

or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

specific language governing permissions and limitations under the

License.  When distributing the software, include this License Header

Notice in each file and include the License file at

nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

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

by Oracle in the GPL Version 2 section of the License file that

accompanied this code. If applicable, add the following below the

License Header, with the fields enclosed by brackets [] replaced by

your own identifying information:

"Portions Copyrighted [year] [name of copyright owner]"

Contributor(s):

The Original Software is NetBeans. The Initial Developer of the Original

Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

Microsystems, Inc. All Rights Reserved.

If you wish your version of this file to be governed by only the CDDL

or only the GPL Version 2, indicate your decision by adding

"[Contributor] elects to include this software in this distribution

under the [CDDL or GPL Version 2] license." If you do not indicate a

single choice of license, a recipient has the option to distribute

your version of this file under either the CDDL, the GPL Version 2 or

to extend the choice of license to its licensees as provided above.

However, if you add GPL Version 2 code and therefore, elected the GPL

Version 2 license, then the option applies only if the new code is

made subject to such option by the copyright holder.

-->

<project name="libs.asm" default="netbeans" basedir=".">

    <import file="../nbbuild/templates/projectized.xml"/>

</project>

Name: OW2 ASM

Version: 5.0.1

License: INRIA license

Origin: http://forge.ow2.org/project/download.php?group_id=23&file_id=19789

OSR: 13078

Description: Bytecode manipulation library

*******************************************************************************

* ASM: a very small and fast Java bytecode manipulation framework

* Copyright (c) 2000-2011 INRIA, France Telecom

* All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

* 1. Redistributions of source code must retain the above copyright

*    notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

*    notice, this list of conditions and the following disclaimer in the

*    documentation and/or other materials provided with the distribution.

* 3. Neither the name of the copyright holders nor the names of its

*    contributors may be used to endorse or promote products derived from

*    this software without specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

* THE POSSIBILITY OF SUCH DAMAGE.

*******************************************************************************

2F7553F50B0D14ED811B849C282DA8C1FFC32AAE asm-all-5.0.1.jar

Manifest-Version: 1.0

OpenIDE-Module: org.netbeans.libs.asm

OpenIDE-Module-Localizing-Bundle: org/netbeans/libs/asm/Bundle.properties

OpenIDE-Module-Specification-Version: 5.1

# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

#

# Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.

#

# Oracle and Java are registered trademarks of Oracle and/or its affiliates.

# Other names may be trademarks of their respective owners.

#

# The contents of this file are subject to the terms of either the GNU

# General Public License Version 2 only ("GPL") or the Common

# Development and Distribution License("CDDL") (collectively, the

# "License"). You may not use this file except in compliance with the

# License. You can obtain a copy of the License at

# http://www.netbeans.org/cddl-gplv2.html

# or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

# specific language governing permissions and limitations under the

# License.  When distributing the software, include this License Header

# Notice in each file and include the License file at

# nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

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

# by Oracle in the GPL Version 2 section of the License file that

# accompanied this code. If applicable, add the following below the

# License Header, with the fields enclosed by brackets [] replaced by

# your own identifying information:

# "Portions Copyrighted [year] [name of copyright owner]"

#

# Contributor(s):

#

# The Original Software is NetBeans. The Initial Developer of the Original

# Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

# Microsystems, Inc. All Rights Reserved.

#

# If you wish your version of this file to be governed by only the CDDL

# or only the GPL Version 2, indicate your decision by adding

# "[Contributor] elects to include this software in this distribution

# under the [CDDL or GPL Version 2] license." If you do not indicate a

# single choice of license, a recipient has the option to distribute

# your version of this file under either the CDDL, the GPL Version 2 or

# to extend the choice of license to its licensees as provided above.

# However, if you add GPL Version 2 code and therefore, elected the GPL

# Version 2 license, then the option applies only if the new code is

# made subject to such option by the copyright holder.

javac.compilerargs=-Xlint -Xlint:-serial

javac.source=1.7

module.jar.dir=lib

release.external/asm-all-5.0.1.jar=lib/ext/asm-5.0.1/asm-all-5.0.1.jar

license.file=../external/asm-all-5.0.1-license.txt

<?xml version="1.0" encoding="UTF-8"?>

<!--

DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.

Oracle and Java are registered trademarks of Oracle and/or its affiliates.

Other names may be trademarks of their respective owners.

The contents of this file are subject to the terms of either the GNU

General Public License Version 2 only ("GPL") or the Common

Development and Distribution License("CDDL") (collectively, the

"License"). You may not use this file except in compliance with the

License. You can obtain a copy of the License at

http://www.netbeans.org/cddl-gplv2.html

or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

specific language governing permissions and limitations under the

License.  When distributing the software, include this License Header

Notice in each file and include the License file at

nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

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

by Oracle in the GPL Version 2 section of the License file that

accompanied this code. If applicable, add the following below the

License Header, with the fields enclosed by brackets [] replaced by

your own identifying information:

"Portions Copyrighted [year] [name of copyright owner]"

Contributor(s):

The Original Software is NetBeans. The Initial Developer of the Original

Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

Microsystems, Inc. All Rights Reserved.

If you wish your version of this file to be governed by only the CDDL

or only the GPL Version 2, indicate your decision by adding

"[Contributor] elects to include this software in this distribution

under the [CDDL or GPL Version 2] license." If you do not indicate a

single choice of license, a recipient has the option to distribute

your version of this file under either the CDDL, the GPL Version 2 or

to extend the choice of license to its licensees as provided above.

However, if you add GPL Version 2 code and therefore, elected the GPL

Version 2 license, then the option applies only if the new code is

made subject to such option by the copyright holder.

-->

<project xmlns="http://www.netbeans.org/ns/project/1">

    <type>org.netbeans.modules.apisupport.project</type>

    <configuration>

        <data xmlns="http://www.netbeans.org/ns/nb-module-project/3">

            <code-name-base>org.netbeans.libs.asm</code-name-base>

            <module-dependencies/>

            <public-packages>

                <subpackages>org</subpackages>

            </public-packages>

            <class-path-extension>

                <runtime-relative-path>ext/asm-5.0.1/asm-all-5.0.1.jar</runtime-relative-path>

                <binary-origin>external/asm-all-5.0.1.jar</binary-origin>

            </class-path-extension>

<!--            <class-path-extension>

                <runtime-relative-path>ext/asm-5.0.1/asm-5.0.1.jar</runtime-relative-path>

                <binary-origin>external/asm-5.0.1.jar</binary-origin>

            </class-path-extension>

            <class-path-extension>

                <runtime-relative-path>ext/asm-5.0.1/asm-commons-5.0.1.jar</runtime-relative-path>

                <binary-origin>external/asm-commons-5.0.1.jar</binary-origin>

            </class-path-extension>

            <class-path-extension>

                <runtime-relative-path>ext/asm-5.0.1/asm-util-5.0.1.jar</runtime-relative-path>

                <binary-origin>external/asm-util-5.0.1.jar</binary-origin>

            </class-path-extension>-->

        </data>

    </configuration>

</project>

# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

#

# Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.

#

# Oracle and Java are registered trademarks of Oracle and/or its affiliates.

# Other names may be trademarks of their respective owners.

#

# The contents of this file are subject to the terms of either the GNU

# General Public License Version 2 only ("GPL") or the Common

# Development and Distribution License("CDDL") (collectively, the

# "License"). You may not use this file except in compliance with the

# License. You can obtain a copy of the License at

# http://www.netbeans.org/cddl-gplv2.html

# or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

# specific language governing permissions and limitations under the

# License.  When distributing the software, include this License Header

# Notice in each file and include the License file at

# nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

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

# by Oracle in the GPL Version 2 section of the License file that

# accompanied this code. If applicable, add the following below the

# License Header, with the fields enclosed by brackets [] replaced by

# your own identifying information:

# "Portions Copyrighted [year] [name of copyright owner]"

#

# Contributor(s):

#

# The Original Software is NetBeans. The Initial Developer of the Original

# Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun

# Microsystems, Inc. All Rights Reserved.

#

# If you wish your version of this file to be governed by only the CDDL

# or only the GPL Version 2, indicate your decision by adding

# "[Contributor] elects to include this software in this distribution

# under the [CDDL or GPL Version 2] license." If you do not indicate a

# single choice of license, a recipient has the option to distribute

# your version of this file under either the CDDL, the GPL Version 2 or

# to extend the choice of license to its licensees as provided above.

# However, if you add GPL Version 2 code and therefore, elected the GPL

# Version 2 license, then the option applies only if the new code is

# made subject to such option by the copyright holder.

OpenIDE-Module-Name=OW2 ASM

OpenIDE-Module-Display-Category=Libraries

OpenIDE-Module-Short-Description=Bundles OW2 ASM (bytecode manipulation)

OpenIDE-Module-Long-Description=\

    This module bundles OW2 ASM (bytecode manipulation library).

        libs.asm,\

    <change id="module.fragments">

         <api name="launcher"/>

         <summary>Ability to join other module</summary>

         <version major="2" minor="69"/>

         <date day="11" month="4" year="2014"/>

         <author login="sdedic"/>

         <compatibility addition="yes" binary="compatible" semantic="compatible" />

         <description>

         <p>

             Module can be declared as <a href="@TOP@architecture-summary.html#modfrag">

                 Module Fragment

             </a> to join other module loader. Fragment classes may ask to be bytecode-patched

             as superclasses of API classes to preserve compatibility.

         </p>

         </description>

         <issue number="243561"/>

     </change>

     <usecase id="modfrag" name="Module Fragments">

         <p>

            This is a specific case of <a href="#usecase-patch">Patch Classes</a> use-case.

            To maintain binary compatibility when <b>removing</b> methods from API classes,

            the "removed" implementation is actually moved to a special class, which becomes

            a <i>superclass</i> of the original API class. Such special classes should be

            separated into a 'compat' module, which is only loaded in presence of old clients.

         </p>

         <p>

            The compat module should declare it is a fragment of the original API module in its

            <code>MANIFEST.MF</code>

         </p>

            <pre>

OpenIDE-Module-Fragment-Host: orignal.module.codename

            </pre>

        <p>

            which ensures contents of the compat module will be loaded using classloader

            of the 'fragment host' module. The compat module will not get its own classloader.

            The special class itself should be marked using <a href="@TOP@/org/netbeans/modules/PatchPublic.html">PatchPublic</a> annotation,

            which causes it will be patched as superclass and inserted into the inheritance

            chain.

         </p>

     </usecase>

                    <code-name-base>org.netbeans.libs.asm</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <specification-version>5.0</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    patchingBytecode = PatchByteCode.fromStream(res, this);

    String getFragmentHostCodeName() {

        return data().getFragmentHostCodeName();

    }

import org.openide.modules.PatchFor;

            String classLoader = attr.getValue(PatchFor.MANIFEST_FRAGMENT_HOST); // NOI18N

            if (classLoader != null) {

                Object[] clParse = Util.parseCodeName(classLoader);

                String frag = (String)clParse[0];

                if (frag != null) {

                    if ((frag = frag.trim()).isEmpty()) {

                        frag = null;

                    }

                }

                this.fragmentHostCodeName = frag;

                if (verifyCNBs && frag != null) {

                    // Indirect way of checking syntax:

                    Dependency.create(Dependency.TYPE_MODULE, fragmentHostCodeName);

                }

            } else {

                fragmentHostCodeName = null;

            }

        this.fragmentHostCodeName = null;

            String s = dis.readUTF();

            if (s != null) {

                s = s.trim();

            }

            this.fragmentHostCodeName = s == null || s.isEmpty() ? null : s;

        dos.writeUTF(fragmentHostCodeName == null ? "" : fragmentHostCodeName);

    final String getFragmentHostCodeName() {

        return fragmentHostCodeName;

    }

    /**

     * Modules whose contents is injected into 

     */

    private final Map<String, Collection<Module>> fragmentModules = new HashMap<String, Collection<Module>>(5);

        // if fragment, integrate into the host's classloader. Should be called under mutex()

        String fragmentHost = m.getFragmentHostCodeName();

        if (fragmentHost == null) {

            return null;

        }

        Module theHost = modulesByName.get(fragmentHost);

        if (theHost == null) {

            throw new IllegalStateException("Missing hosting module " + fragmentHost + " for fragment " + m.getCodeName());

        }

        return theHost.getClassLoader();

    /**

     * Refines the module's own path with patches from other modules

     * @param m the module

     * @param path the ordered list of classpath fragments

     */

    void refineModulePath(Module m, List<File> path) {

        String cnb = m.getCodeNameBase();

        Collection<Module> injectList = fragmentModules.get(cnb);

        if (injectList == null) {

            return;

        }

        for (Module inject : injectList) {

            Util.err.log(Level.FINER, "Compat: injecting contents of fragment " + inject.getCodeNameBase() + " into " + m.getCodeNameBase());

            List<File> allJars = inject.getAllJars();

            // PENDING: shouldn't we add those jars first, so they take precedence ?

            path.addAll(allJars);

        }

    }

    /**

     * Attaches a fragment to an existing module. The hosting module must NOT

     * be already enabled, otherwise an exception will be thrown. Enabled module

     * may have some classes already loaded, and they cannot be patched.

     * 

     * @param m module to attach if it is a fragment

     */

    private void attachModuleFragment(Module m) {

        String codeNameBase = m.getFragmentHostCodeName();

        if (codeNameBase == null) {

            return;

        }

        Module host = modulesByName.get(codeNameBase);

        if (host != null && host.isEnabled()) {

            throw new IllegalStateException("Module " + host.getCodeName() + " is already enabled");

        }

        Collection<Module> frags = fragmentModules.get(codeNameBase);

        if (frags == null) {

            frags = new ArrayList<Module>(1);

            fragmentModules.put(codeNameBase, frags);

        }

        frags.add(m);

    }

    /**

     * Removes a fragment module. Throws an exception if the fragment's

     * host is already enabled and its classloader may have loaded fragment's

     * contents.

     * <p/>

     * The method does nothing for non-fragment modules

     * 

     * @param m the module to remove

     */

    private void removeFragmentFromHost(Module m) {

        String fragHost = m.getFragmentHostCodeName();

        if (fragHost == null) {

            return;

        }

        Module hostMod = modulesByName.get(fragHost);

        if (hostMod != null && hostMod.isEnabled()) {

            throw new IllegalStateException("Host module " + m.getCodeName() + " was loaded, cannot remove fragment");

        }

        Collection<Module> frags = fragmentModules.get(fragHost);

        if (frags != null) {

            frags.remove(m);

        }

    }

        removeFragmentFromHost(m);

            // first connect fragments to their hosts, so classloaders are populated

            for (Module m: toEnable) {

                if (m.isEnabled()) {

                    continue;

                }

                // store information from fragment modules for early initialization of hosting classlaoder:

                attachModuleFragment(m);

            }

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.net.URL;

import java.util.Collection;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Properties;

import java.util.logging.Logger;

import org.objectweb.asm.ClassReader;

import org.objectweb.asm.ClassWriter;

import org.objectweb.asm.Opcodes;

import org.objectweb.asm.signature.SignatureReader;

import org.objectweb.asm.signature.SignatureVisitor;

import org.objectweb.asm.tree.AbstractInsnNode;

import org.objectweb.asm.tree.AnnotationNode;

import org.objectweb.asm.tree.ClassNode;

import org.objectweb.asm.tree.MethodInsnNode;

import org.objectweb.asm.tree.MethodNode;

    private static final String DESC_CTOR_ANNOTATION = "Lorg/openide/modules/ConstructorDelegate;";

    private static final String DESC_PATCHED_PUBLIC_ANNOTATION = "Lorg/openide/modules/PatchedPublic;";

    private static final String DESC_DEFAULT_CTOR = "()V";

    private static final String CONSTRUCTOR_NAME = "<init>"; // NOI18N

    private static final String PREFIX_EXTEND = "extend."; // NOI18N

    /**

     * Shared instance, which does just nothing

     */

    private static final PatchByteCode NOP = new PatchByteCode(false, null, null);

    /**

     * Shared instance, that performs a very fast PatchedPublic patch on the loaded class

     */

    private static final PatchByteCode PUBLIC_ONLY = new PatchByteCode(true, null, null);

    private final boolean patchPublic;

    private final Map<String, String> classToExtend;

    private final ClassLoader theClassLoader;

    private PatchByteCode() {

        this(false, null, null);

    }

    private PatchByteCode(boolean pub, Map<String, String> classToExtend, ClassLoader ldr) {

        this.patchPublic = pub;

        this.classToExtend = classToExtend;

        this.theClassLoader = ldr;

    }

    private void load(URL stream) throws IOException {

        try (InputStream istm = stream.openStream()) {

            Properties props = new Properties();

            props.load(new InputStreamReader(istm, "UTF-8")); // NOI18N

            Enumeration<String> en = (Enumeration<String>)props.propertyNames();

            while (en.hasMoreElements()) {

                String pn = en.nextElement();

                if (pn.startsWith(PREFIX_EXTEND)) {

                    String toExtend = pn.substring(PREFIX_EXTEND.length());

                    String extendWith = props.getProperty(pn);

                    String old;

                    if ((old = classToExtend.put(toExtend, extendWith)) != null) {

                        throw new IOException("Multiple extend instructions for class" + toExtend + ": " + extendWith + " and " + old);

                    }

                }

            }

        }

    }

    private PatchByteCode purify() {

        if (classToExtend == null || classToExtend.isEmpty()) {

            return PUBLIC_ONLY;

        } else {

            return this;

        }

    }

    static PatchByteCode fromStream(Enumeration<URL> streams, ClassLoader ldr) {

        PatchByteCode pb = new PatchByteCode(false, new HashMap<String, String>(3), ldr);

        boolean found = false;

        while (streams.hasMoreElements()) {

            URL stream = streams.nextElement();

            try {

                pb.load(stream);

            } catch (IOException ex) {

                // TODO: log

            }

            found = true;

        }

        return found ? pb.purify() : NOP;

    }

    byte[] apply(String className, byte[] data) throws IOException {

        if (patchPublic) {

            return patch(data);

        } else if (classToExtend == null) {

            return data;

        }

        // more thorough analysis is needed.

        String extender = classToExtend.get(className);

        if (extender == null) {

            return patch(data);

        }

        // must analyze the extender class, as some annotations there may trigger 

        ClassReader clr = new ClassReader(data);

        ClassWriter wr = new ClassWriter(clr, 0);

        ClassNode theClass = new ClassNode();

        clr.accept(theClass, 0);

        MethodNode defCtor = null;

        String extInternalName = extender.replace(".", "/"); // NOI18N

        // patch the superclass

        theClass.superName = extInternalName;

        String resName = extInternalName + ".class"; // NOI18N

        try (InputStream istm = theClassLoader.getResourceAsStream(resName)) {

            if (istm == null) {

                throw new IOException("Could not find classfile for extender class"); // NOI18N

            }

            ClassReader extenderReader = new ClassReader(istm);

            ClassNode extenderClass = new ClassNode();

            extenderReader.accept(extenderClass, ClassReader.SKIP_FRAMES);

            // search for a no-arg ctor, replace all invokespecial calls in ctors

            for (MethodNode m : (Collection<MethodNode>)theClass.methods) {

                if (CONSTRUCTOR_NAME.equals(m.name)) {

                    if (DESC_DEFAULT_CTOR.equals(m.desc)) { // NOI18N

                        defCtor = m;

                    }

                    replaceSuperCtorCalls(theClass, extenderClass, m);

                }

            }

            for (Object o : extenderClass.methods) {

                MethodNode mn = (MethodNode)o;

                if (mn.invisibleAnnotations != null && (mn.access & Opcodes.ACC_STATIC) > 0) {

                    // constructor, possibly annotated

                    for (AnnotationNode an : (Collection<AnnotationNode>)mn.invisibleAnnotations) {

                        if (DESC_CTOR_ANNOTATION.equals(an.desc)) {

                            delegateToFactory(extenderClass, mn, theClass, defCtor);

                            break;

                        }

                    }

                }

            }

            for (MethodNode mn : (Collection<MethodNode>)theClass.methods) {

                if (mn.invisibleAnnotations == null) {

                    continue;

                }

                for (AnnotationNode an : (Collection<AnnotationNode>)mn.invisibleAnnotations) {

                    if (DESC_PATCHED_PUBLIC_ANNOTATION.equals(an.desc)) {

                        mn.access = (mn.access & ~(Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED)) | Opcodes.ACC_PUBLIC;

                        break;

                    }

                }

            }

        }

        theClass.accept(wr);

        byte[] result = wr.toByteArray();

        return result;

    }

    /**

     * Replaces class references in super constructor invocations.

     * Must not replace references in this() constructor invocations.

     * 

     * @param theClass the class being patched

     * @param extenderClass the injected superclass

     * @param mn method to process

     */

    private void replaceSuperCtorCalls(final ClassNode theClass, final ClassNode extenderClass, MethodNode mn) {

        for (Iterator it = mn.instructions.iterator(); it.hasNext(); ) {

            AbstractInsnNode aIns = (AbstractInsnNode)it.next();

            if (aIns.getOpcode() == Opcodes.INVOKESPECIAL) {

                MethodInsnNode mins = (MethodInsnNode)aIns;

                if (CONSTRUCTOR_NAME.equals(mins.name) && !mins.owner.equals(theClass.name)) {

                    // replace with the extender class name

                    mins.owner = extenderClass.name;

                }

                break;

            }

        }

    }

    /**

     * No-op singature visitor

     */

    private static class NullSignVisitor extends SignatureVisitor {

        public NullSignVisitor() {

            super(Opcodes.ASM5);

        }

    }

    /**

     * Pushes parameters with correct opcodes that correspond to the

     * method's signature. Assumes that the first parameter is the

     * object's class itself.

     */

    private static class CallParametersWriter extends SignatureVisitor {

        private final MethodNode mn;

        private int localSize;

        /**

         * Adds opcodes to the method's code

         * 

         * @param mn method to generate

         * @param firstSelf if true, assumes the first parameter is reference to self and will generate aload_0

         */

        public CallParametersWriter(MethodNode mn, boolean firstSelf) {

            super(Opcodes.ASM5);

            this.mn = mn;

            this.paramIndex = firstSelf ? 0 : 1;

        }

        private int paramIndex = 1;

        @Override

        public void visitEnd() {

            // end of classtype

            mn.visitVarInsn(Opcodes.ALOAD, paramIndex++);

            localSize++;

        }

        @Override

        public void visitBaseType(char c) {

            int idx = paramIndex++;

            int opcode;

            switch (c) {

                // two-word data

                case 'J': opcode = Opcodes.LLOAD; paramIndex++; localSize++; break;

                case 'D': opcode = Opcodes.DLOAD; paramIndex++; localSize++; break;

                // float has a special opcode

                case 'F': opcode = Opcodes.FLOAD; break;

                default: opcode = Opcodes.ILOAD; break;

            }

            mn.visitVarInsn(opcode, idx);

            localSize++;

        }

        @Override

        public SignatureVisitor visitTypeArgument(char c) {

            return new NullSignVisitor();

        }

        @Override

        public void visitTypeArgument() {}

        @Override

        public void visitInnerClassType(String string) {}

        @Override

        public void visitClassType(String string) {}

        @Override

        public SignatureVisitor visitArrayType() {

            mn.visitVarInsn(Opcodes.ALOAD, paramIndex++);

            return new NullSignVisitor();

        }

        @Override

        public void visitTypeVariable(String string) {}

        @Override

        public SignatureVisitor visitExceptionType() {

            return new NullSignVisitor();

        }

        @Override

        public SignatureVisitor visitReturnType() {

            return new NullSignVisitor();

        }

        @Override

        public SignatureVisitor visitParameterType() {

            return this;

        }

        @Override

        public SignatureVisitor visitInterface() {

            return null;

        }

        @Override

        public SignatureVisitor visitSuperclass() {

            return null;

        }

        @Override

        public SignatureVisitor visitInterfaceBound() {

            return new NullSignVisitor();

        }

        @Override

        public SignatureVisitor visitClassBound() {

            return new NullSignVisitor();

        }

        @Override

        public void visitFormalTypeParameter(String string) {

            super.visitFormalTypeParameter(string); //To change body of generated methods, choose Tools | Templates.

        }

    }

    private void delegateToFactory(ClassNode targetClass, MethodNode targetMethod, ClassNode clazz,

            MethodNode noArgCtor) {

        String desc = targetMethod.desc;

        // assume the first parameter is the class:

        int nextPos = desc.indexOf(';', 2); // NOI18N

        desc = "(" + desc.substring(nextPos + 1); // NOI18N

        MethodNode mn = new MethodNode(Opcodes.ASM5, 

                targetMethod.access & (~Opcodes.ACC_STATIC), CONSTRUCTOR_NAME,

                desc,

                targetMethod.signature,

                (String[])targetMethod.exceptions.toArray(new String[targetMethod.exceptions.size()]));

        mn.visibleAnnotations = targetMethod.visibleAnnotations;

        mn.visibleParameterAnnotations = targetMethod.visibleParameterAnnotations;

        mn.parameters = targetMethod.parameters;

        mn.exceptions = targetMethod.exceptions;

        mn.visitCode();

        // this();

        mn.visitVarInsn(Opcodes.ALOAD, 0);

        mn.visitMethodInsn(Opcodes.INVOKESPECIAL, 

                clazz.name, 

                noArgCtor.name, noArgCtor.desc, false);

        // push parameters

        SignatureReader r = new SignatureReader(targetMethod.desc);

        CallParametersWriter callWr = new CallParametersWriter(mn, true);

        r.accept(callWr);

        mn.visitMethodInsn(Opcodes.INVOKESTATIC, targetClass.name, targetMethod.name, targetMethod.desc, false);

        mn.visitInsn(Opcodes.RETURN);

        mn.maxStack = callWr.localSize;

        mn.maxLocals = callWr.localSize;

        clazz.methods.add(mn);

    }

        // possibly inject some patches

        getManager().refineModulePath(this, classp);

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.net.URL;

import java.util.Enumeration;

import org.openide.modules.ConstructorDelegate;

import org.openide.modules.PatchFor;

    public static class Superclazz {

        public int val;

    }

    public static class CAPI extends Superclazz {

        public int otherVal;

        public CAPI() {

            otherVal = 1;

        }

    }

    @PatchFor(CAPI.class)

    public static class CompatAPI extends Superclazz {

        @ConstructorDelegate

        protected static void createAPI(CompatAPI inst, int val2) {

            inst.val = val2;

        }

    }

    public void testPatchSuperclass() throws Exception {

        Class<?> c = new L().loadClass(CAPI.class.getName());

        assertNotSame(c, CAPI.class);

        Class s = c.getSuperclass();

        assertNotSame(s, Object.class);

        assertEquals(CompatAPI.class.getName(), s.getName());

    }

    public void testGeneratedConstructor() throws Exception {

        Class<?> c = new L().loadClass(CAPI.class.getName());

        Member m = c.getDeclaredConstructor(int.class);

        assertEquals(Modifier.PROTECTED, m.getModifiers() & (Modifier.PRIVATE | Modifier.PROTECTED | Modifier.PRIVATE));

    }

    public void testExecutingConstructor() throws Exception {

        ClassLoader l = new L();

        Class<?> c = l.loadClass(CAPI.class.getName());        

        Member m = c.getDeclaredConstructor(int.class);

        Constructor ctor = (Constructor)m;

        ctor.setAccessible(true);

        Object o = ctor.newInstance(5);

        assertSame(c, o.getClass());

        assertTrue("Invalid API superclass", Superclazz.class.isInstance(o));

        assertEquals("@ConstructorDelegate method did not execute", 5, ((Superclazz)o).val);

        Field f = o.getClass().getField("otherVal");

        Object v = f.get(o);

        assertEquals("Patched API constructor did not execute", v, 1);

    }

    <change id="PatchSuper">

        <api name="modules"/>

        <summary>Support for binary compatibility patches</summary>

        <version major="7" minor="44"/>

        <date day="11" month="4" year="2014"/>

        <author login="sdedic"/>

        <compatibility addition="yes" binary="compatible" semantic="compatible" source="compatible"/>

        <description>

            <p>

                When removing @deprecated code from API, it is still desirable to retain

                backward binary compatibility. Because of JVM method/field/class resolution

                mechanism, it is permitted to move the implementation upwards the inheritance

                hierarchy. However, the superclass that receives the methods must

                not be visible in the sources (otherwise the change would not serve any good) and

                specifically, must not be referenced from `extends' clause of the changed class.

            </p>

            <p>

                The compatibility superclass ought to reside in a completely different module to

                allow reduce type dependencies and should be only injected into inheritance chain

                if and only if some of enabled modules depend on the obsolete version of the API module.

            </p>

            <p>

                Special annotation <a href="@TOP@/org/netbeans/modules/PatchFor.html"><code>@PatchFor</code></a>

                allows to require that a class should serve as a <i>superclass</i> of some other class.

                See <a href="@TOP@/org/netbeans/modules/PatchFor.html">@PatchFor javadoc</a> for further 

                constraints.

            </p>

            <p>

                The constructor cannot be 'just moved', because of it contains instance variable initialization

                code. To support removing obsolete constructors, 

                <a href="@TOP@/org/netbeans/modules/ConstructorDelegate.html"><code>@ConstructorDelegate</code></a> has been

                created to mark moved initialization code. See <a href="@TOP@/org/netbeans/modules/ConstructorDelegate.html">@ConstructorDelegate javadoc</a>

                for more details.

            </p>

            <p>

                The module which contains such patches must share the classloader with the patched one,

                since classes in those two modules reference each other. A new Manifest entry, <strong>

                    <code>OpenIDE-Module-Fragment-Host</code>

                </strong>, is defined. It's value must be set to <strong>codename</strong> of the

                patched module.

            </p>

        </description>

        <class package="org.netbeans.modules" name="PatchFor"/>

        <class package="org.netbeans.modules" name="ConstructorDelegate"/>

        <issue number="243561"/>

    </change>

  <usecase id="patchfor" name="Runtime compatibility patches">

      <p>

        To maintain binary compatibility, method implementations may be injected

        at runtime, in a form of a superclass in the class' inheritance hierarchy.

        Modules compiled against older version of APIs which contains MethodReferences to 

        methods removed from the oficial APIs will be then linked according to JVM Resolution

        algorithm to a matching method present in the superclass of the referenced type.

      </p>

      <p>

        Annotations are used to instruct the ClassLoader to make transformations to the API

          classes. <a href="@TOP@/org/netbeans/modules/PatchFor.html">PatchFor</a> causes the annotated

          class to be injected as a superclass of the API class identified by the annotation's value.

          <a href="@TOP@/org/netbeans/modules/ConstructorDelegate.html">ConstructorDelegate</a> marks

          a method, which is called as constructor implementation in the case that it is necessary

          to preserve a constructor for binary compatibility.

      </p>

  </usecase>

import java.io.BufferedWriter;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.util.Map;

import javax.lang.model.element.AnnotationMirror;

import javax.lang.model.element.AnnotationValue;

import javax.lang.model.element.ElementKind;

import javax.lang.model.element.ExecutableElement;

import javax.lang.model.type.DeclaredType;

import javax.lang.model.type.TypeMirror;

import org.openide.modules.ConstructorDelegate;

import org.openide.modules.PatchFor;

    private static final Set<String> ANNOTATIONS = new HashSet<String>(

        Arrays.asList(

            PatchedPublic.class.getCanonicalName(),

            PatchFor.class.getCanonicalName(),

            ConstructorDelegate.class.getCanonicalName()

        )

    );

    private void flush(RoundEnvironment roundEnv) {

        if (!originatingElements.isEmpty()) {

            try (OutputStream os = processingEnv.getFiler().createResource(

                    StandardLocation.CLASS_OUTPUT,

                    "", "META-INF/.bytecodePatched",

                    originatingElements.toArray(new Element[originatingElements.size()])).openOutputStream()) {

                BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os, "UTF-8"));

                for (Map.Entry<String, String> exEntry : superclasses.entrySet()) {

                    String api = exEntry.getKey();

                    String sup = exEntry.getValue();

                    bw.append("extend.").append(api).append("=").append(sup);

                    bw.newLine();

                }

                bw.flush();

            } catch (IOException x) {

                processingEnv.getMessager().printMessage(Kind.ERROR, x.getMessage());

            }

        }

    }

    private TypeElement implForElement;

    private Element valueElement;

    private boolean reported;

    private TypeElement getImplFor() {

        implForElement = processingEnv.getElementUtils().getTypeElement(IMPL_FOR_NAME);

        if (implForElement == null) {

            if (!reported) {

                processingEnv.getMessager().printMessage(Kind.ERROR, "Cannot find @ImplementationFor annotation");

                reported = true;

            }

            return null;

        }

        for (Element e : implForElement.getEnclosedElements()) {

            if (e.getKind() == ElementKind.METHOD && e.getSimpleName().contentEquals("value")) {

                valueElement = e;

                break;

            }

        }

        return implForElement;

    }

    private static final String IMPL_FOR_NAME = PatchFor.class.getName();

        CLAZZ: for (Element e : roundEnv.getElementsAnnotatedWith(PatchFor.class)) {

            List<? extends AnnotationMirror> mirrors = e.getAnnotationMirrors();

            String apiName = null;

            TypeElement target = null;

            for (AnnotationMirror m : mirrors) {

                Element me = m.getAnnotationType().asElement();

                if (me != getImplFor()) {

                    continue;

                }

                AnnotationValue val = m.getElementValues().get(valueElement);

                if (!(val.getValue() instanceof DeclaredType)) {

                    processingEnv.getMessager().printMessage(Kind.ERROR, "Value for @ImplementationFor must be a valid class", e);

                    continue CLAZZ;

                }

                Element x = ((DeclaredType)val.getValue()).asElement();

                if (!(x instanceof TypeElement)) {

                    processingEnv.getMessager().printMessage(Kind.ERROR, "Value for @ImplementationFor must be a valid class", e);

                    continue CLAZZ;

                }

                target = (TypeElement)x;

                if (target.getKind() != ElementKind.CLASS) {

                    processingEnv.getMessager().printMessage(Kind.ERROR, "@ImplementationFor can be only applied on classes", e);

                    continue CLAZZ;

                }

                apiName = processingEnv.getElementUtils().getBinaryName(target).toString();

                break;

            }

            if (target == null) {

                throw new IllegalStateException();

            }

            TypeElement t = (TypeElement)e;

            boolean defaultCtorFound = false;

            for (Element el : target.getEnclosedElements()) {

                if (el.getKind() != ElementKind.CONSTRUCTOR) {

                    continue;

                }

                if (((ExecutableElement)el).getParameters().isEmpty()) {

                    defaultCtorFound = true;

                    break;

                }

            }

            if (!defaultCtorFound) {

                processingEnv.getMessager().printMessage(Kind.ERROR, "Class " + t.getQualifiedName().toString() + " has no default constructor", e);

                continue CLAZZ;

            }

            String superName = processingEnv.getElementUtils().getBinaryName(t).toString();

            TypeMirror patchSuperClass = t.getSuperclass();

            TypeMirror targetSuperClass = target.getSuperclass();

            if (!processingEnv.getTypeUtils().isSameType(patchSuperClass, targetSuperClass)) {

                processingEnv.getMessager().printMessage(Kind.ERROR, "API class and the substitue differ in their superclasses", e);

                continue CLAZZ;

            }

            superclasses.put(apiName, superName);

            processingEnv.getMessager().printMessage(Kind.NOTE, "Adding injection of " + superName + " as a superclass of API " + apiName);

            originatingElements.add(e);

        }

/*

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

 *

 * Copyright 2014 Oracle and/or its affiliates. All rights reserved.