/*
 * Bytecode Analysis Framework
 * Copyright (C) 2003,2004 University of Maryland
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package edu.umd.cs.findbugs.ba;

import java.util.Collection;
import java.util.HashSet;

import edu.umd.cs.findbugs.ba.vna.ValueNumber;
import edu.umd.cs.findbugs.ba.vna.ValueNumberFactory;
import edu.umd.cs.findbugs.ba.vna.ValueNumberFrame;

/**
 * Lock counts for values (as produced by ValueNumberAnalysis). A LockSet tells
 * us the lock counts for all values in a method, insofar as we can accurately
 * determine them.
 * 
 * @author David Hovemeyer
 * @see edu.umd.cs.findbugs.ba.vna.ValueNumberAnalysis
 */
public final class LockSet {
    /**
     * An uninitialized lock value.
     */
    public static final int TOP = -1;

    /**
     * An invalid lock count resulting from the meet of two different
     * (inconsistent) lock counts.
     */
    public static final int BOTTOM = -2;

    private static final int INVALID = -1;

    private static final int DEFAULT_CAPACITY = 8;

    /**
     * Lock counts are stored in an array. Even indices <i>i</i> are value
     * numbers of lock objects. Odd indices <i>i+1</i> are lock counts. This
     * representation is fairly compact in memory.
     */
    private int[] array;

    /**
     * The lock count value to return for nonexistent lock entries.
     */
    private int defaultLockCount;

    /**
     * Constructor. Creates an empty lock set which returns TOP for nonexistent
     * lock entries.
     */
    public LockSet() {
        this.array = new int[DEFAULT_CAPACITY];
        this.defaultLockCount = TOP;
        clear();
    }

    /**
     * Get the lock count for given lock object.
     * 
     * @param valueNumber
     *            value number of the lock object
     * @return the lock count for the lock object
     */
    public int getLockCount(int valueNumber) {
        int index = findIndex(valueNumber);
        if (index < 0)
            return defaultLockCount;
        else
            return array[index + 1];
    }

    public boolean isTop() {
        return defaultLockCount == TOP;
    }

    /**
     * Set the lock count for a lock object.
     * 
     * @param valueNumber
     *            value number of the lock object
     * @param lockCount
     *            the lock count for the lock
     */
    public void setLockCount(int valueNumber, int lockCount) {
        int index = findIndex(valueNumber);
        if (index < 0) {
            addEntry(index, valueNumber, lockCount);
        } else {
            array[index + 1] = lockCount;
        }
    }

    /**
     * Set the default lock count to return for nonexistent lock entries.
     * 
     * @param defaultLockCount
     *            the default lock count value
     */
    public void setDefaultLockCount(int defaultLockCount) {
        this.defaultLockCount = defaultLockCount;
    }

    /**
     * Get the number of distinct lock values with positive lock counts.
     */
    public int getNumLockedObjects() {
        int result = 0;
        for (int i = 0; i < array.length; i += 2) {
            if (array[i] == INVALID)
                break;
            if (array[i + 1] > 0)
                ++result;
        }
        return result;
    }

    /**
     * Make this LockSet the same as the given one.
     * 
     * @param other
     *            the LockSet to copy
     */
    public void copyFrom(LockSet other) {
        if (other.array.length != array.length) {
            array = new int[other.array.length];
        }
        System.arraycopy(other.array, 0, array, 0, array.length);
        this.defaultLockCount = other.defaultLockCount;
    }

    /**
     * Clear all entries out of this LockSet.
     */
    public void clear() {
        for (int i = 0; i < array.length; i += 2) {
            array[i] = INVALID;
        }
    }

    /**
     * Meet this LockSet with another LockSet, storing the result in this
     * object.
     * 
     * @param other
     *            the other LockSet
     */
    public void meetWith(LockSet other) {
        for (int i = 0; i < array.length; i += 2) {
            int valueNumber = array[i];
            if (valueNumber < 0)
                break;

            int mine = array[i + 1];
            int his = other.getLockCount(valueNumber);
            array[i + 1] = mergeValues(mine, his);
        }

        for (int i = 0; i < other.array.length; i += 2) {
            int valueNumber = other.array[i];
            if (valueNumber < 0)
                break;

            int mine = getLockCount(valueNumber);
            int his = other.array[i + 1];
            setLockCount(valueNumber, mergeValues(mine, his));
        }

        setDefaultLockCount(0);
    }

    /**
     * Return whether or not this LockSet is the same as the one given.
     * 
     * @param other
     *            the other LockSet
     */
    public boolean sameAs(LockSet other) {
        return this.identicalSubset(other) && other.identicalSubset(this);
    }

    /**
     * Determine whether or not this lock set contains any locked values which
     * are method return values.
     * 
     * @param factory
     *            the ValueNumberFactory that produced the lock values
     */
    public boolean containsReturnValue(ValueNumberFactory factory) {
        for (int i = 0; i < array.length; i += 2) {
            int valueNumber = array[i];
            if (valueNumber < 0)
                break;
            int lockCount = array[i + 1];
            if (lockCount > 0 && factory.forNumber(valueNumber).hasFlag(ValueNumber.RETURN_VALUE))
                return true;
        }
        return false;
    }

    /**
     * Destructively intersect this lock set with another. Note that this is
     * <em>not</em> a dataflow merge: we are interested in finding out which
     * locks are held in both sets, not in the exact lock counts.
     * 
     * @param other
     *            the other LockSet
     */
    public void intersectWith(LockSet other) {
        for (int i = 0; i < array.length; i += 2) {
            int valueNumber = array[i];
            if (valueNumber < 0)
                break;
            int myLockCount = array[i + 1];
            if (myLockCount <= 0)
                continue;
            int otherLockCount = other.getLockCount(valueNumber);
            if (otherLockCount <= 0) {
                /* This set holds the lock, but the other one doesn't. */
                array[i + 1] = 0;
            }
        }
    }

    /**
     * Return whether or not this lock set is empty, meaning that no locks have
     * a positive lock count.
     * 
     * @return true if no locks are held, false if at least one lock is held
     */
    public boolean isEmpty() {
        for (int i = 0; i < array.length; i += 2) {
            int valueNumber = array[i];
            if (valueNumber < 0)
                return true;
            int myLockCount = array[i + 1];
            if (myLockCount > 0)
                return false;
        }
        return true;
    }

    private boolean identicalSubset(LockSet other) {
        for (int i = 0; i < array.length; i += 2) {
            int valueNumber = array[i];
            if (valueNumber < 0)
                break;
            int mine = array[i + 1];
            int his = other.getLockCount(valueNumber);
            if (mine != his)
                return false;
            // System.out.println("For value " + valueNumber + ", " + mine +
            // "==" + his);
        }
        return true;
    }

    private static int mergeValues(int a, int b) {
        if (a == TOP)
            return b;
        else if (b == TOP)
            return a;
        else if (a == BOTTOM || b == BOTTOM)
            return BOTTOM;
        else if (a == b)
            return a;
        else
            return BOTTOM;
    }

    private int findIndex(int valueNumber) {
        for (int i = 0; i < array.length; i += 2) {
            int value = array[i];
            if (value < 0)
                return -(i + 1); // didn't find requested valueNumber - return
                                 // first available slot
            else if (value == valueNumber)
                return i; // found requested valueNumber
        }
        return -(array.length + 1); // didn't find requested valueNumber, and
                                    // array is full
    }

    private void addEntry(int negatedIndex, int valueNumber, int lockCount) {
        int index = -(negatedIndex + 1);
        int origCapacity = array.length;
        if (index == origCapacity) {
            // Grow the array.

            // Allocate twice the space of the old array
            int[] data = new int[origCapacity * 2];

            // Copy existing data
            System.arraycopy(array, 0, data, 0, origCapacity);

            // Clear entries in the new part of the array
            // that won't be used to store the entry that's
            // being added
            for (int i = index + 2; i < data.length; i += 2) {
                data[i] = INVALID;
            }

            // Now we're ready to use the new array
            array = data;
        }

        array[index] = valueNumber;
        array[index + 1] = lockCount;
    }

    @Override
    public String toString() {
        StringBuilder buf = new StringBuilder();
        buf.append('[');
        boolean first = true;
        if (defaultLockCount == 0) {
            buf.append("default=0");
            first = false;
        }
        for (int i = 0; i < array.length; i += 2) {
            int valueNumber = array[i];
            if (valueNumber < 0)
                continue;
            int lockCount = array[i + 1];
            if (lockCount == 0)
                continue;
            if (first)
                first = false;
            else
                buf.append(',');
            buf.append(valueNumber);
            buf.append('=');
            if (lockCount == TOP)
                buf.append("TOP");
            else if (lockCount == BOTTOM)
                buf.append("BOTTOM");
            else
                buf.append(lockCount);
        }
        buf.append(']');
        return buf.toString();
    }

    /**
     * @param frame
     * @return a set of the locked value numbers
     */
    public Collection<ValueNumber> getLockedValueNumbers(ValueNumberFrame frame) {
        if (frame == null)
            throw new IllegalArgumentException("Null Frame");
        HashSet<ValueNumber> result = new HashSet<ValueNumber>();
        for (ValueNumber v : frame.allSlots())
            if (v != null && getLockCount(v.getNumber()) > 0)
                result.add(v);
        return result;
    }

    /*
     * public static void main(String[] argv) { LockSet l = new LockSet();
     * l.setLockCount(0, 1); System.out.println(l); l.setLockCount(0, 2);
     * System.out.println(l); l.setLockCount(15, 1); System.out.println(l);
     * LockSet ll = new LockSet(); ll.setLockCount(0, 1); ll.setLockCount(15,
     * 1); ll.setLockCount(69, 3); LockSet tmp = new LockSet();
     * tmp.copyFrom(ll); ll.meetWith(l); System.out.println(l + " merge with " +
     * tmp + " ==> " + ll);
     * 
     * LockSet dup = new LockSet(); dup.copyFrom(ll); System.out.println(ll +
     * " == " + dup + " ==> " + ll.sameAs(dup)); System.out.println(ll + " == "
     * + l + " ==> " + ll.sameAs(l)); }
     */
}

// vim:ts=4
