/*

 */

/*

 *

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

/*

 * $Id: MethodGenerator.java,v 1.2.4.1 2005/09/05 11:16:47 pvedula Exp $

 */

package com.sun.org.apache.xalan.internal.xsltc.compiler.util;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Stack;

import com.sun.org.apache.bcel.internal.Constants;

import com.sun.org.apache.bcel.internal.classfile.Field;

import com.sun.org.apache.bcel.internal.classfile.Method;

import com.sun.org.apache.bcel.internal.generic.ALOAD;

import com.sun.org.apache.bcel.internal.generic.ASTORE;

import com.sun.org.apache.bcel.internal.generic.BranchHandle;

import com.sun.org.apache.bcel.internal.generic.BranchInstruction;

import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;

import com.sun.org.apache.bcel.internal.generic.DLOAD;

import com.sun.org.apache.bcel.internal.generic.DSTORE;

import com.sun.org.apache.bcel.internal.generic.FLOAD;

import com.sun.org.apache.bcel.internal.generic.FSTORE;

import com.sun.org.apache.bcel.internal.generic.GETFIELD;

import com.sun.org.apache.bcel.internal.generic.GOTO;

import com.sun.org.apache.bcel.internal.generic.ICONST;

import com.sun.org.apache.bcel.internal.generic.IfInstruction;

import com.sun.org.apache.bcel.internal.generic.ILOAD;

import com.sun.org.apache.bcel.internal.generic.IndexedInstruction;

import com.sun.org.apache.bcel.internal.generic.INVOKEINTERFACE;

import com.sun.org.apache.bcel.internal.generic.INVOKESPECIAL;

import com.sun.org.apache.bcel.internal.generic.INVOKESTATIC;

import com.sun.org.apache.bcel.internal.generic.INVOKEVIRTUAL;

import com.sun.org.apache.bcel.internal.generic.ISTORE;

import com.sun.org.apache.bcel.internal.generic.Instruction;

import com.sun.org.apache.bcel.internal.generic.InstructionConstants;

import com.sun.org.apache.bcel.internal.generic.InstructionHandle;

import com.sun.org.apache.bcel.internal.generic.InstructionList;

import com.sun.org.apache.bcel.internal.generic.InstructionTargeter;

import com.sun.org.apache.bcel.internal.generic.LocalVariableGen;

import com.sun.org.apache.bcel.internal.generic.LocalVariableInstruction;

import com.sun.org.apache.bcel.internal.generic.LLOAD;

import com.sun.org.apache.bcel.internal.generic.LSTORE;

import com.sun.org.apache.bcel.internal.generic.MethodGen;

import com.sun.org.apache.bcel.internal.generic.NEW;

import com.sun.org.apache.bcel.internal.generic.PUTFIELD;

import com.sun.org.apache.bcel.internal.generic.RET;

import com.sun.org.apache.bcel.internal.generic.Select;

import com.sun.org.apache.bcel.internal.generic.TargetLostException;

import com.sun.org.apache.bcel.internal.generic.Type;

import com.sun.org.apache.xalan.internal.xsltc.compiler.Pattern;

import com.sun.org.apache.xalan.internal.xsltc.compiler.XSLTC;

/**

 * @author Jacek Ambroziak

 * @author Santiago Pericas-Geertsen

 */

public class MethodGenerator extends MethodGen

    implements com.sun.org.apache.xalan.internal.xsltc.compiler.Constants {

    protected static final int INVALID_INDEX   = -1;

    private static final String START_ELEMENT_SIG

        = "(" + STRING_SIG + ")V";

    private static final String END_ELEMENT_SIG

        = START_ELEMENT_SIG;

    private InstructionList _mapTypeSub;

    private static final int DOM_INDEX       = 1;

    private static final int ITERATOR_INDEX  = 2;

    private static final int HANDLER_INDEX   = 3;

    private static final int MAX_METHOD_SIZE = 65535;

    private static final int MAX_BRANCH_TARGET_OFFSET = 32767;

    private static final int MIN_BRANCH_TARGET_OFFSET = -32768;

    private static final int TARGET_METHOD_SIZE = 60000;

    private static final int MINIMUM_OUTLINEABLE_CHUNK_SIZE = 1000;

    private Instruction       _iloadCurrent;

    private Instruction       _istoreCurrent;

    private final Instruction _astoreHandler;

    private final Instruction _aloadHandler;

    private final Instruction _astoreIterator;

    private final Instruction _aloadIterator;

    private final Instruction _aloadDom;

    private final Instruction _astoreDom;

    private final Instruction _startElement;

    private final Instruction _endElement;

    private final Instruction _startDocument;

    private final Instruction _endDocument;

    private final Instruction _attribute;

    private final Instruction _uniqueAttribute;

    private final Instruction _namespace;

    private final Instruction _setStartNode;

    private final Instruction _reset;

    private final Instruction _nextNode;

    private SlotAllocator _slotAllocator;

    private boolean _allocatorInit = false;

    private LocalVariableRegistry _localVariableRegistry;

        /**

                 * A mapping between patterns and instruction lists used by

                 * test sequences to avoid compiling the same pattern multiple

                 * times. Note that patterns whose kernels are "*", "node()"

                 * and "@*" can between shared by test sequences.

                 */

    public MethodGenerator(int access_flags, Type return_type,

                           Type[] arg_types, String[] arg_names,

                           String method_name, String class_name,

                           InstructionList il, ConstantPoolGen cpg) {

        super(access_flags, return_type, arg_types, arg_names, method_name,

              class_name, il, cpg);

        _astoreHandler  = new ASTORE(HANDLER_INDEX);

        _aloadHandler   = new ALOAD(HANDLER_INDEX);

        _astoreIterator = new ASTORE(ITERATOR_INDEX);

        _aloadIterator  = new ALOAD(ITERATOR_INDEX);

        _aloadDom       = new ALOAD(DOM_INDEX);

        _astoreDom      = new ASTORE(DOM_INDEX);

        final int startElement =

            cpg.addInterfaceMethodref(TRANSLET_OUTPUT_INTERFACE,

                                      "startElement",

                                      START_ELEMENT_SIG);

        _startElement = new INVOKEINTERFACE(startElement, 2);

        final int endElement =

            cpg.addInterfaceMethodref(TRANSLET_OUTPUT_INTERFACE,

                                      "endElement",

                                      END_ELEMENT_SIG);

        _endElement = new INVOKEINTERFACE(endElement, 2);

        final int attribute =

            cpg.addInterfaceMethodref(TRANSLET_OUTPUT_INTERFACE,

                                      "addAttribute",

                                      "("

                                      + STRING_SIG

                                      + STRING_SIG

                                      + ")V");

        _attribute = new INVOKEINTERFACE(attribute, 3);

        final int uniqueAttribute =

            cpg.addInterfaceMethodref(TRANSLET_OUTPUT_INTERFACE,

                                      "addUniqueAttribute",

                                      "("

                                      + STRING_SIG

                                      + STRING_SIG

                                      + "I)V");

        _uniqueAttribute = new INVOKEINTERFACE(uniqueAttribute, 4);

        final int namespace =

            cpg.addInterfaceMethodref(TRANSLET_OUTPUT_INTERFACE,

                                      "namespaceAfterStartElement",

                                      "("

                                      + STRING_SIG

                                      + STRING_SIG

                                      + ")V");

        _namespace = new INVOKEINTERFACE(namespace, 3);

        int index = cpg.addInterfaceMethodref(TRANSLET_OUTPUT_INTERFACE,

                                              "startDocument",

                                              "()V");

        _startDocument = new INVOKEINTERFACE(index, 1);

        index = cpg.addInterfaceMethodref(TRANSLET_OUTPUT_INTERFACE,

                                          "endDocument",

                                          "()V");

        _endDocument = new INVOKEINTERFACE(index, 1);

        index = cpg.addInterfaceMethodref(NODE_ITERATOR,

                                          SET_START_NODE,

                                          SET_START_NODE_SIG);

        _setStartNode = new INVOKEINTERFACE(index, 2);

        index = cpg.addInterfaceMethodref(NODE_ITERATOR,

                                          "reset", "()"+NODE_ITERATOR_SIG);

        _reset = new INVOKEINTERFACE(index, 1);

        index = cpg.addInterfaceMethodref(NODE_ITERATOR, NEXT, NEXT_SIG);

        _nextNode = new INVOKEINTERFACE(index, 1);

        _slotAllocator = new SlotAllocator();

        _slotAllocator.initialize(getLocalVariableRegistry().getLocals(false));

        _allocatorInit = true;

    }

    /**

     * Allocates a local variable. If the slot allocator has already been

     * initialized, then call addLocalVariable2() so that the new variable

     * is known to the allocator. Failing to do this may cause the allocator

     * to return a slot that is already in use.

     */

    public LocalVariableGen addLocalVariable(String name, Type type,

                                             InstructionHandle start,

                                             InstructionHandle end)

    {

        LocalVariableGen lvg;

        if (_allocatorInit) {

            lvg = addLocalVariable2(name, type, start);

        } else {

            lvg = super.addLocalVariable(name, type, start, end);

            getLocalVariableRegistry().registerLocalVariable(lvg);

        }

        return lvg;

    }

    public LocalVariableGen addLocalVariable2(String name, Type type,

                                              InstructionHandle start)

    {

        LocalVariableGen lvg = super.addLocalVariable(name, type,

                                              _slotAllocator.allocateSlot(type),

                                              start, null);

        getLocalVariableRegistry().registerLocalVariable(lvg);

        return lvg;

    }

    private LocalVariableRegistry getLocalVariableRegistry() {

        if (_localVariableRegistry == null) {

            _localVariableRegistry = new LocalVariableRegistry();

        }

        return _localVariableRegistry;

    }

    /**

     * Keeps track of all local variables used in the method.

     * <p>The

     * {@link MethodGen#addLocalVariable(String,Type,InstructionHandle,InstructionHandle)}</code>

     * and

     * {@link MethodGen#addLocalVariable(String,Type,int,InstructionHandle,InstructionHandle)}</code>

     * methods of {@link MethodGen} will only keep track of

     * {@link LocalVariableGen} object until it'ss removed by a call to

     * {@link MethodGen#removeLocalVariable(LocalVariableGen)}.</p>

     * <p>In order to support efficient copying of local variables to outlined

     * methods by

     * {@link #outline(InstructionHandle,InstructionHandle,String,ClassGenerator)},

     * this class keeps track of all local variables defined by the method.</p>

     */

    protected class LocalVariableRegistry {

        /**

         * <p>A <code>java.lang.ArrayList</code> of all

         * {@link LocalVariableGen}s created for this method, indexed by the

         * slot number of the local variable.  The JVM stack frame of local

         * variables is divided into "slots".  A single slot can be used to

         * store more than one variable in a method, without regard to type, so

         * long as the byte code keeps the ranges of the two disjoint.</p>

         * <p>If only one registration of use of a particular slot occurs, the

         * corresponding entry of <code>_variables</code> contains the

         * <code>LocalVariableGen</code>; if more than one occurs, the

         * corresponding entry contains all such <code>LocalVariableGen</code>s

         * registered for the same slot; and if none occurs, the entry will be

         * <code>null</code>.

         */

        protected ArrayList _variables = new ArrayList();

        /**

         * Maps a name to a {@link LocalVariableGen}

         */

        protected HashMap _nameToLVGMap = new HashMap();

        /**

         * Registers a {@link org.apache.bcel.generic.LocalVariableGen}

         * for this method.

         * <p><b>Preconditions:</b>

         * <ul>

         * <li>The range of instructions for <code>lvg</code> does not

         * overlap with the range of instructions for any

         * <code>LocalVariableGen</code> with the same slot index previously

         * registered for this method.  <b><em>(Unchecked.)</em></b></li>

         * </ul></p>

         * @param lvg The variable to be registered

         */

        protected void registerLocalVariable(LocalVariableGen lvg) {

            int slot = lvg.getIndex();

            int registrySize = _variables.size();

            // If the LocalVariableGen uses a slot index beyond any previously

            // encountered, expand the _variables, padding with intervening null

            // entries as required.

            if (slot >= registrySize) {

                for (int i = registrySize; i < slot; i++) {

                    _variables.add(null);

                }

                _variables.add(lvg);

            } else {

                // If the LocalVariableGen reuses a slot, make sure the entry

                // in _variables contains an ArrayList and add the newly

                // registered LocalVariableGen to the list.  If the entry in

                // _variables just contains null padding, store the

                // LocalVariableGen directly.

                Object localsInSlot = _variables.get(slot);

                if (localsInSlot != null) {

                    if (localsInSlot instanceof LocalVariableGen) {

                        ArrayList listOfLocalsInSlot = new ArrayList();

                        listOfLocalsInSlot.add(localsInSlot);

                        listOfLocalsInSlot.add(lvg);

                        _variables.set(slot, listOfLocalsInSlot);

                    } else {

                        ((ArrayList) localsInSlot).add(lvg);

                    }

                } else {

                    _variables.set(slot, lvg);

                }

            }

            registerByName(lvg);

        }

        /**

         * <p>Find which {@link LocalVariableGen}, if any, is registered for a

         * particular JVM local stack frame slot at a particular position in the

         * byte code for the method.</p>

         * <p><b>Preconditions:</b>

         * <ul>

         * <li>The {@link InstructionList#setPositions()} has been called for

         * the {@link InstructionList} associated with this

         * {@link MethodGenerator}.</li>

         * </ul></p>

         * @param slot the JVM local stack frame slot number

         * @param offset the position in the byte code

         * @return the <code>LocalVariableGen</code> for the local variable

         * stored in the relevant slot at the relevant offset; <code>null</code>

         * if there is none.

         */

        protected LocalVariableGen lookupRegisteredLocalVariable(int slot,

                                                                 int offset) {

            Object localsInSlot = (_variables != null) ? _variables.get(slot)

                                                       : null;

            // If this slot index was never used, _variables.get will return

            // null; if it was used once, it will return the LocalVariableGen;

            // more than once it will return an ArrayList of all the

            // LocalVariableGens for variables stored in that slot.  For each

            // LocalVariableGen, check whether its range includes the

            // specified offset, and return the first such encountered.

            if (localsInSlot != null) {

                if (localsInSlot instanceof LocalVariableGen) {

                    LocalVariableGen lvg = (LocalVariableGen)localsInSlot;

                    if (offsetInLocalVariableGenRange(lvg, offset)) {

                        return lvg;

                    }

                } else {

                    ArrayList listOfLocalsInSlot = (ArrayList) localsInSlot;

                    int size = listOfLocalsInSlot.size();

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

                        LocalVariableGen lvg =

                            (LocalVariableGen)listOfLocalsInSlot.get(i);

                        if (offsetInLocalVariableGenRange(lvg, offset)) {

                            return lvg;

                        }

                    }

                }

            }

            // No local variable stored in the specified slot at the specified

            return null;

        }

        /**

         * <p>Set up a mapping of the name of the specified

         * {@link LocalVariableGen} object to the <code>LocalVariableGen</code>

         * itself.</p>

         * <p>This is a bit of a hack.  XSLTC is relying on the fact that the

         * name that is being looked up won't be duplicated, which isn't

         * guaranteed.  It replaces code which used to call

         * {@link MethodGen#getLocalVariables()} and looped through the

         * <code>LocalVariableGen</code> objects it contained to find the one

         * with the specified name.  However, <code>getLocalVariables()</code>

         * has the side effect of setting the start and end for any

         * <code>LocalVariableGen</code> which did not already have them

         * set, which causes problems for outlining..</p>

         * <p>See also {@link #lookUpByName(String)} and

         * {@link #removeByNameTracking(LocalVariableGen)}</P

         * @param lvg a <code>LocalVariableGen</code>

         */

        protected void registerByName(LocalVariableGen lvg) {

            Object duplicateNameEntry = _nameToLVGMap.get(lvg.getName());

            if (duplicateNameEntry == null) {

                _nameToLVGMap.put(lvg.getName(), lvg);

            } else {

                ArrayList sameNameList;

                if (duplicateNameEntry instanceof ArrayList) {

                    sameNameList = (ArrayList) duplicateNameEntry;

                    sameNameList.add(lvg);

                } else {

                    sameNameList = new ArrayList();

                    sameNameList.add(duplicateNameEntry);

                    sameNameList.add(lvg);

                }

                _nameToLVGMap.put(lvg.getName(), sameNameList);

            }

        }

        /**

         * Remove the mapping from the name of the specified

         * {@link LocalVariableGen} to itself.

         * See also {@link #registerByName(LocalVariableGen)} and

         * {@link #lookUpByName(String)}

         * @param lvg a <code>LocalVariableGen</code>

         */

        protected void removeByNameTracking(LocalVariableGen lvg) {

            Object duplicateNameEntry = _nameToLVGMap.get(lvg.getName());

            if (duplicateNameEntry instanceof ArrayList) {

                ArrayList sameNameList = (ArrayList) duplicateNameEntry;

                for (int i = 0; i < sameNameList.size(); i++) {

                    if (sameNameList.get(i) == lvg) {

                        sameNameList.remove(i);

                        break;

                    }

                }

            } else {

                _nameToLVGMap.remove(lvg);

            }

        }

        /**

         * <p>Given the name of a variable, finds a {@link LocalVariableGen}

         * corresponding to it.</p>

         * <p>See also {@link #registerByName(LocalVariableGen)} and

         * {@link #removeByNameTracking(LocalVariableGen)}</p>

         * @param name

         * @return

         */

        protected LocalVariableGen lookUpByName(String name) {

            LocalVariableGen lvg = null;

            Object duplicateNameEntry = _nameToLVGMap.get(name);

            if (duplicateNameEntry instanceof ArrayList) {

                ArrayList sameNameList = (ArrayList) duplicateNameEntry;

                for (int i = 0; i < sameNameList.size(); i++) {

                    lvg = (LocalVariableGen)sameNameList.get(i);

                    if (lvg.getName() == name) {

                        break;

                    }

                }

            } else {

                lvg = (LocalVariableGen) duplicateNameEntry;

            }

            return lvg;

        }

        /**

         * <p>Gets all {@link LocalVariableGen} objects for this method.</p>

         * <p>When the <code>includeRemoved</code> argument has the value

         * <code>false</code>, this method replaces uses of

         * {@link MethodGen#getLocalVariables()} which has

         * a side-effect of setting the start and end range for any

         * <code>LocalVariableGen</code> if either was <code>null</code>.  That

         * side-effect causes problems for outlining of code in XSLTC.

         * @param includeRemoved Specifies whether all local variables ever

         * declared should be returned (<code>true</code>) or only those not

         * removed (<code>false</code>)

         * @return an array of <code>LocalVariableGen</code> containing all the

         * local variables

         */

        protected LocalVariableGen[] getLocals(boolean includeRemoved) {

            LocalVariableGen[] locals = null;

            ArrayList allVarsEverDeclared = new ArrayList();

            if (includeRemoved) {

                int slotCount = allVarsEverDeclared.size();

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

                    Object slotEntries = _variables.get(i);

                    if (slotEntries != null) {

                        if (slotEntries instanceof ArrayList) {