https://openjdk.java.net/ 
/*
 * 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.
 */

/*
 * This file is available under and governed by the GNU General Public
 * License version 2 only, as published by the Free Software Foundation.
 * However, the following notice accompanied the original version of this
 * file:
 *
 * 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.
 */
package jdk.internal.org.objectweb.asm.tree;

import java.util.ListIterator;
import java.util.NoSuchElementException;

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


A doubly linked list of AbstractInsnNode objects. This
implementation is not thread safe.

/**
 * A doubly linked list of {@link AbstractInsnNode} objects. <i>This
 * implementation is not thread safe</i>.
 */
public class InsnList {

    
The number of instructions in this list.

/**
     * The number of instructions in this list.
     */
    private int size;

    
The first instruction in this list. May be null.

/**
     * The first instruction in this list. May be <tt>null</tt>.
     */
    private AbstractInsnNode first;

    
The last instruction in this list. May be null.

/**
     * The last instruction in this list. May be <tt>null</tt>.
     */
    private AbstractInsnNode last;

    
A cache of the instructions of this list. This cache is used to improve the performance of the get method. 
/**
     * A cache of the instructions of this list. This cache is used to improve
     * the performance of the {@link #get} method.
     */
    AbstractInsnNode[] cache;

    
Returns the number of instructions in this list.

Returns:the number of instructions in this list.
/**
     * Returns the number of instructions in this list.
     *
     * @return the number of instructions in this list.
     */
    public int size() {
        return size;
    }

    
Returns the first instruction in this list.

Returns:the first instruction in this list, or null if the list
        is empty.
/**
     * Returns the first instruction in this list.
     *
     * @return the first instruction in this list, or <tt>null</tt> if the list
     *         is empty.
     */
    public AbstractInsnNode getFirst() {
        return first;
    }

    
Returns the last instruction in this list.

Returns:the last instruction in this list, or null if the list
        is empty.
/**
     * Returns the last instruction in this list.
     *
     * @return the last instruction in this list, or <tt>null</tt> if the list
     *         is empty.
     */
    public AbstractInsnNode getLast() {
        return last;
    }

    
Returns the instruction whose index is given. This method builds a cache
of the instructions in this list to avoid scanning the whole list each
time it is called. Once the cache is built, this method run in constant
time. This cache is invalidated by all the methods that modify the list.

Params:
  • index – 
           the index of the instruction that must be returned.
Throws:
Returns:the instruction whose index is given.
/**
     * Returns the instruction whose index is given. This method builds a cache
     * of the instructions in this list to avoid scanning the whole list each
     * time it is called. Once the cache is built, this method run in constant
     * time. This cache is invalidated by all the methods that modify the list.
     *
     * @param index
     *            the index of the instruction that must be returned.
     * @return the instruction whose index is given.
     * @throws IndexOutOfBoundsException
     *             if (index &lt; 0 || index &gt;= size()).
     */
    public AbstractInsnNode get(final int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
        if (cache == null) {
            cache = toArray();
        }
        return cache[index];
    }

    
Returns true if the given instruction belongs to this list. This
method always scans the instructions of this list until it finds the
given instruction or reaches the end of the list.

Params:
  • insn – 
           an instruction.
Returns:true if the given instruction belongs to this list.
/**
     * Returns <tt>true</tt> if the given instruction belongs to this list. This
     * method always scans the instructions of this list until it finds the
     * given instruction or reaches the end of the list.
     *
     * @param insn
     *            an instruction.
     * @return <tt>true</tt> if the given instruction belongs to this list.
     */
    public boolean contains(final AbstractInsnNode insn) {
        AbstractInsnNode i = first;
        while (i != null && i != insn) {
            i = i.next;
        }
        return i != null;
    }

    
Returns the index of the given instruction in this list. This method
builds a cache of the instruction indexes to avoid scanning the whole
list each time it is called. Once the cache is built, this method run in
constant time. The cache is invalidated by all the methods that modify
the list.

Params:
  • insn – 
           an instruction of this list.
Returns:the index of the given instruction in this list. The result of
        this method is undefined if the given instruction does not belong
        to this list. Use contains to test if an instruction belongs to an instruction list or not.
/**
     * Returns the index of the given instruction in this list. This method
     * builds a cache of the instruction indexes to avoid scanning the whole
     * list each time it is called. Once the cache is built, this method run in
     * constant time. The cache is invalidated by all the methods that modify
     * the list.
     *
     * @param insn
     *            an instruction <i>of this list</i>.
     * @return the index of the given instruction in this list. <i>The result of
     *         this method is undefined if the given instruction does not belong
     *         to this list</i>. Use {@link #contains contains} to test if an
     *         instruction belongs to an instruction list or not.
     */
    public int indexOf(final AbstractInsnNode insn) {
        if (cache == null) {
            cache = toArray();
        }
        return insn.index;
    }

    
Makes the given visitor visit all of the instructions in this list.

Params:
  • mv – 
           the method visitor that must visit the instructions.
/**
     * Makes the given visitor visit all of the instructions in this list.
     *
     * @param mv
     *            the method visitor that must visit the instructions.
     */
    public void accept(final MethodVisitor mv) {
        AbstractInsnNode insn = first;
        while (insn != null) {
            insn.accept(mv);
            insn = insn.next;
        }
    }

    
Returns an iterator over the instructions in this list.

Returns:an iterator over the instructions in this list.
/**
     * Returns an iterator over the instructions in this list.
     *
     * @return an iterator over the instructions in this list.
     */
    public ListIterator<AbstractInsnNode> iterator() {
        return iterator(0);
    }

    
Returns an iterator over the instructions in this list.

Params:
  • index – 
           index of instruction for the iterator to start at
Returns:an iterator over the instructions in this list.
/**
     * Returns an iterator over the instructions in this list.
     *
     * @param index
     *            index of instruction for the iterator to start at
     *
     * @return an iterator over the instructions in this list.
     */
    @SuppressWarnings("unchecked")
    public ListIterator<AbstractInsnNode> iterator(int index) {
        return new InsnListIterator(index);
    }

    
Returns an array containing all of the instructions in this list.

Returns:an array containing all of the instructions in this list.
/**
     * Returns an array containing all of the instructions in this list.
     *
     * @return an array containing all of the instructions in this list.
     */
    public AbstractInsnNode[] toArray() {
        int i = 0;
        AbstractInsnNode elem = first;
        AbstractInsnNode[] insns = new AbstractInsnNode[size];
        while (elem != null) {
            insns[i] = elem;
            elem.index = i++;
            elem = elem.next;
        }
        return insns;
    }

    
Replaces an instruction of this list with another instruction.

Params:
  • location – 
           an instruction of this list.
  • insn – 
           another instruction, which must not belong to any InsnList.
/**
     * Replaces an instruction of this list with another instruction.
     *
     * @param location
     *            an instruction <i>of this list</i>.
     * @param insn
     *            another instruction, <i>which must not belong to any
     *            {@link InsnList}</i>.
     */
    public void set(final AbstractInsnNode location, final AbstractInsnNode insn) {
        AbstractInsnNode next = location.next;
        insn.next = next;
        if (next != null) {
            next.prev = insn;
        } else {
            last = insn;
        }
        AbstractInsnNode prev = location.prev;
        insn.prev = prev;
        if (prev != null) {
            prev.next = insn;
        } else {
            first = insn;
        }
        if (cache != null) {
            int index = location.index;
            cache[index] = insn;
            insn.index = index;
        } else {
            insn.index = 0; // insn now belongs to an InsnList
        }
        location.index = -1; // i no longer belongs to an InsnList
        location.prev = null;
        location.next = null;
    }

    
Adds the given instruction to the end of this list.

Params:
  • insn – 
           an instruction, which must not belong to any InsnList.
/**
     * Adds the given instruction to the end of this list.
     *
     * @param insn
     *            an instruction, <i>which must not belong to any
     *            {@link InsnList}</i>.
     */
    public void add(final AbstractInsnNode insn) {
        ++size;
        if (last == null) {
            first = insn;
            last = insn;
        } else {
            last.next = insn;
            insn.prev = last;
        }
        last = insn;
        cache = null;
        insn.index = 0; // insn now belongs to an InsnList
    }

    
Adds the given instructions to the end of this list.

Params:
  • insns – 
           an instruction list, which is cleared during the process. This
           list must be different from 'this'.
/**
     * Adds the given instructions to the end of this list.
     *
     * @param insns
     *            an instruction list, which is cleared during the process. This
     *            list must be different from 'this'.
     */
    public void add(final InsnList insns) {
        if (insns.size == 0) {
            return;
        }
        size += insns.size;
        if (last == null) {
            first = insns.first;
            last = insns.last;
        } else {
            AbstractInsnNode elem = insns.first;
            last.next = elem;
            elem.prev = last;
            last = insns.last;
        }
        cache = null;
        insns.removeAll(false);
    }

    
Inserts the given instruction at the begining of this list.

Params:
  • insn – 
           an instruction, which must not belong to any InsnList.
/**
     * Inserts the given instruction at the begining of this list.
     *
     * @param insn
     *            an instruction, <i>which must not belong to any
     *            {@link InsnList}</i>.
     */
    public void insert(final AbstractInsnNode insn) {
        ++size;
        if (first == null) {
            first = insn;
            last = insn;
        } else {
            first.prev = insn;
            insn.next = first;
        }
        first = insn;
        cache = null;
        insn.index = 0; // insn now belongs to an InsnList
    }

    
Inserts the given instructions at the begining of this list.

Params:
  • insns – 
           an instruction list, which is cleared during the process. This
           list must be different from 'this'.
/**
     * Inserts the given instructions at the begining of this list.
     *
     * @param insns
     *            an instruction list, which is cleared during the process. This
     *            list must be different from 'this'.
     */
    public void insert(final InsnList insns) {
        if (insns.size == 0) {
            return;
        }
        size += insns.size;
        if (first == null) {
            first = insns.first;
            last = insns.last;
        } else {
            AbstractInsnNode elem = insns.last;
            first.prev = elem;
            elem.next = first;
            first = insns.first;
        }
        cache = null;
        insns.removeAll(false);
    }

    
Inserts the given instruction after the specified instruction.

Params:
  • location – 
           an instruction of this list after which insn must be
           inserted.
  • insn – 
           the instruction to be inserted, which must not belong to any InsnList.
/**
     * Inserts the given instruction after the specified instruction.
     *
     * @param location
     *            an instruction <i>of this list</i> after which insn must be
     *            inserted.
     * @param insn
     *            the instruction to be inserted, <i>which must not belong to
     *            any {@link InsnList}</i>.
     */
    public void insert(final AbstractInsnNode location,
            final AbstractInsnNode insn) {
        ++size;
        AbstractInsnNode next = location.next;
        if (next == null) {
            last = insn;
        } else {
            next.prev = insn;
        }
        location.next = insn;
        insn.next = next;
        insn.prev = location;
        cache = null;
        insn.index = 0; // insn now belongs to an InsnList
    }

    
Inserts the given instructions after the specified instruction.

Params:
  • location – 
           an instruction of this list after which the
           instructions must be inserted.
  • insns – 
           the instruction list to be inserted, which is cleared during
           the process. This list must be different from 'this'.
/**
     * Inserts the given instructions after the specified instruction.
     *
     * @param location
     *            an instruction <i>of this list</i> after which the
     *            instructions must be inserted.
     * @param insns
     *            the instruction list to be inserted, which is cleared during
     *            the process. This list must be different from 'this'.
     */
    public void insert(final AbstractInsnNode location, final InsnList insns) {
        if (insns.size == 0) {
            return;
        }
        size += insns.size;
        AbstractInsnNode ifirst = insns.first;
        AbstractInsnNode ilast = insns.last;
        AbstractInsnNode next = location.next;
        if (next == null) {
            last = ilast;
        } else {
            next.prev = ilast;
        }
        location.next = ifirst;
        ilast.next = next;
        ifirst.prev = location;
        cache = null;
        insns.removeAll(false);
    }

    
Inserts the given instruction before the specified instruction.

Params:
  • location – 
           an instruction of this list before which insn must be
           inserted.
  • insn – 
           the instruction to be inserted, which must not belong to any InsnList.
/**
     * Inserts the given instruction before the specified instruction.
     *
     * @param location
     *            an instruction <i>of this list</i> before which insn must be
     *            inserted.
     * @param insn
     *            the instruction to be inserted, <i>which must not belong to
     *            any {@link InsnList}</i>.
     */
    public void insertBefore(final AbstractInsnNode location,
            final AbstractInsnNode insn) {
        ++size;
        AbstractInsnNode prev = location.prev;
        if (prev == null) {
            first = insn;
        } else {
            prev.next = insn;
        }
        location.prev = insn;
        insn.next = location;
        insn.prev = prev;
        cache = null;
        insn.index = 0; // insn now belongs to an InsnList
    }

    
Inserts the given instructions before the specified instruction.

Params:
  • location – 
           an instruction of this list before which the
           instructions must be inserted.
  • insns – 
           the instruction list to be inserted, which is cleared during
           the process. This list must be different from 'this'.
/**
     * Inserts the given instructions before the specified instruction.
     *
     * @param location
     *            an instruction <i>of this list</i> before which the
     *            instructions must be inserted.
     * @param insns
     *            the instruction list to be inserted, which is cleared during
     *            the process. This list must be different from 'this'.
     */
    public void insertBefore(final AbstractInsnNode location,
            final InsnList insns) {
        if (insns.size == 0) {
            return;
        }
        size += insns.size;
        AbstractInsnNode ifirst = insns.first;
        AbstractInsnNode ilast = insns.last;
        AbstractInsnNode prev = location.prev;
        if (prev == null) {
            first = ifirst;
        } else {
            prev.next = ifirst;
        }
        location.prev = ilast;
        ilast.next = location;
        ifirst.prev = prev;
        cache = null;
        insns.removeAll(false);
    }

    
Removes the given instruction from this list.

Params:
  • insn – 
           the instruction of this list that must be removed.
/**
     * Removes the given instruction from this list.
     *
     * @param insn
     *            the instruction <i>of this list</i> that must be removed.
     */
    public void remove(final AbstractInsnNode insn) {
        --size;
        AbstractInsnNode next = insn.next;
        AbstractInsnNode prev = insn.prev;
        if (next == null) {
            if (prev == null) {
                first = null;
                last = null;
            } else {
                prev.next = null;
                last = prev;
            }
        } else {
            if (prev == null) {
                first = next;
                next.prev = null;
            } else {
                prev.next = next;
                next.prev = prev;
            }
        }
        cache = null;
        insn.index = -1; // insn no longer belongs to an InsnList
        insn.prev = null;
        insn.next = null;
    }

    
Removes all of the instructions of this list.

Params:
  • mark –  if the instructions must be marked as no longer belonging to any InsnList.
/**
     * Removes all of the instructions of this list.
     *
     * @param mark
     *            if the instructions must be marked as no longer belonging to
     *            any {@link InsnList}.
     */
    void removeAll(final boolean mark) {
        if (mark) {
            AbstractInsnNode insn = first;
            while (insn != null) {
                AbstractInsnNode next = insn.next;
                insn.index = -1; // insn no longer belongs to an InsnList
                insn.prev = null;
                insn.next = null;
                insn = next;
            }
        }
        size = 0;
        first = null;
        last = null;
        cache = null;
    }

    
Removes all of the instructions of this list.

/**
     * Removes all of the instructions of this list.
     */
    public void clear() {
        removeAll(false);
    }

    
Reset all labels in the instruction list. This method should be called
before reusing same instructions list between several
ClassWriters.

/**
     * Reset all labels in the instruction list. This method should be called
     * before reusing same instructions list between several
     * <code>ClassWriter</code>s.
     */
    public void resetLabels() {
        AbstractInsnNode insn = first;
        while (insn != null) {
            if (insn instanceof LabelNode) {
                ((LabelNode) insn).resetLabel();
            }
            insn = insn.next;
        }
    }

    // this class is not generified because it will create bridges
    @SuppressWarnings("rawtypes")
    private final class InsnListIterator implements ListIterator {

        AbstractInsnNode next;

        AbstractInsnNode prev;

        AbstractInsnNode remove;

        InsnListIterator(int index) {
            if (index == size()) {
                next = null;
                prev = getLast();
            } else {
                next = get(index);
                prev = next.prev;
            }
        }

        public boolean hasNext() {
            return next != null;
        }

        public Object next() {
            if (next == null) {
                throw new NoSuchElementException();
            }
            AbstractInsnNode result = next;
            prev = result;
            next = result.next;
            remove = result;
            return result;
        }

        public void remove() {
            if (remove != null) {
                if (remove == next) {
                    next = next.next;
                } else {
                    prev = prev.prev;
                }
                InsnList.this.remove(remove);
                remove = null;
            } else {
                throw new IllegalStateException();
            }
        }

        public boolean hasPrevious() {
            return prev != null;
        }

        public Object previous() {
            AbstractInsnNode result = prev;
            next = result;
            prev = result.prev;
            remove = result;
            return result;
        }

        public int nextIndex() {
            if (next == null) {
                return size();
            }
            if (cache == null) {
                cache = toArray();
            }
            return next.index;
        }

        public int previousIndex() {
            if (prev == null) {
                return -1;
            }
            if (cache == null) {
                cache = toArray();
            }
            return prev.index;
        }

        public void add(Object o) {
            if (next != null) {
                InsnList.this.insertBefore(next, (AbstractInsnNode) o);
            } else if (prev != null) {
                InsnList.this.insert(prev, (AbstractInsnNode) o);
            } else {
                InsnList.this.add((AbstractInsnNode) o);
            }
            prev = (AbstractInsnNode) o;
            remove = null;
        }

        public void set(Object o) {
            if (remove != null) {
                InsnList.this.set(remove, (AbstractInsnNode) o);
                if (remove == prev) {
                    prev = (AbstractInsnNode) o;
                } else {
                    next = (AbstractInsnNode) o;
                }
            } else {
                throw new IllegalStateException();
            }
        }
    }
}