/*

 * 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-2007 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 com.sun.xml.internal.ws.org.objectweb.asm;

import java.lang.reflect.Constructor;

import java.lang.reflect.Method;

/**

 * A Java type. This class can be used to make it easier to manipulate type and

 * method descriptors.

 *

 * @author Eric Bruneton

 * @author Chris Nokleberg

 */

public class Type {

    /**

     * The sort of the <tt>void</tt> type. See {@link #getSort getSort}.

     */

    public static final int VOID = 0;

    /**

     * The sort of the <tt>boolean</tt> type. See {@link #getSort getSort}.

     */

    public static final int BOOLEAN = 1;

    /**

     * The sort of the <tt>char</tt> type. See {@link #getSort getSort}.

     */

    public static final int CHAR = 2;

    /**

     * The sort of the <tt>byte</tt> type. See {@link #getSort getSort}.

     */

    public static final int BYTE = 3;

    /**

     * The sort of the <tt>short</tt> type. See {@link #getSort getSort}.

     */

    public static final int SHORT = 4;

    /**

     * The sort of the <tt>int</tt> type. See {@link #getSort getSort}.

     */

    public static final int INT = 5;

    /**

     * The sort of the <tt>float</tt> type. See {@link #getSort getSort}.

     */

    public static final int FLOAT = 6;

    /**

     * The sort of the <tt>long</tt> type. See {@link #getSort getSort}.

     */

    public static final int LONG = 7;

    /**

     * The sort of the <tt>double</tt> type. See {@link #getSort getSort}.

     */

    public static final int DOUBLE = 8;

    /**

     * The sort of array reference types. See {@link #getSort getSort}.

     */

    public static final int ARRAY = 9;

    /**

     * The sort of object reference type. See {@link #getSort getSort}.

     */

    public static final int OBJECT = 10;

    /**

     * The <tt>void</tt> type.

     */

    public static final Type VOID_TYPE = new Type(VOID);

    /**

     * The <tt>boolean</tt> type.

     */

    public static final Type BOOLEAN_TYPE = new Type(BOOLEAN);

    /**

     * The <tt>char</tt> type.

     */

    public static final Type CHAR_TYPE = new Type(CHAR);

    /**

     * The <tt>byte</tt> type.

     */

    public static final Type BYTE_TYPE = new Type(BYTE);

    /**

     * The <tt>short</tt> type.

     */

    public static final Type SHORT_TYPE = new Type(SHORT);

    /**

     * The <tt>int</tt> type.

     */

    public static final Type INT_TYPE = new Type(INT);

    /**

     * The <tt>float</tt> type.

     */

    public static final Type FLOAT_TYPE = new Type(FLOAT);

    /**

     * The <tt>long</tt> type.

     */

    public static final Type LONG_TYPE = new Type(LONG);

    /**

     * The <tt>double</tt> type.

     */

    public static final Type DOUBLE_TYPE = new Type(DOUBLE);

    // ------------------------------------------------------------------------

    // Fields

    // ------------------------------------------------------------------------

    /**

     * The sort of this Java type.

     */

    private final int sort;

    /**

     * A buffer containing the internal name of this Java type. This field is

     * only used for reference types.

     */

    private final char[] buf;

    /**

     * The offset of the internal name of this Java type in {@link #buf buf}.

     * This field is only used for reference types.

     */

    private final int off;

    /**

     * The length of the internal name of this Java type. This field is only

     * used for reference types.

     */

    private final int len;

    // ------------------------------------------------------------------------

    // Constructors

    // ------------------------------------------------------------------------

    /**

     * Constructs a primitive type.

     *

     * @param sort the sort of the primitive type to be constructed.

     */

    private Type(final int sort) {

        this(sort, null, 0, 1);

    }

    /**

     * Constructs a reference type.

     *

     * @param sort the sort of the reference type to be constructed.

     * @param buf a buffer containing the descriptor of the previous type.

     * @param off the offset of this descriptor in the previous buffer.

     * @param len the length of this descriptor.

     */

    private Type(final int sort, final char[] buf, final int off, final int len)

    {

        this.sort = sort;

        this.buf = buf;

        this.off = off;

        this.len = len;

    }

    /**

     * Returns the Java type corresponding to the given type descriptor.

     *

     * @param typeDescriptor a type descriptor.

     * @return the Java type corresponding to the given type descriptor.

     */

    public static Type getType(final String typeDescriptor) {

        return getType(typeDescriptor.toCharArray(), 0);

    }

    /**

     * Returns the Java type corresponding to the given internal name.

     *

     * @param internalName an internal name.

     * @return the Java type corresponding to the given internal name.

     */

    public static Type getObjectType(final String internalName) {

        char[] buf = internalName.toCharArray();

        return new Type(buf[0] == '[' ? ARRAY : OBJECT, buf, 0, buf.length);

    }

    /**

     * Returns the Java type corresponding to the given class.

     *

     * @param c a class.

     * @return the Java type corresponding to the given class.

     */

    public static Type getType(final Class c) {

        if (c.isPrimitive()) {

            if (c == Integer.TYPE) {

                return INT_TYPE;

            } else if (c == Void.TYPE) {

                return VOID_TYPE;

            } else if (c == Boolean.TYPE) {

                return BOOLEAN_TYPE;

            } else if (c == Byte.TYPE) {

                return BYTE_TYPE;

            } else if (c == Character.TYPE) {

                return CHAR_TYPE;

            } else if (c == Short.TYPE) {

                return SHORT_TYPE;

            } else if (c == Double.TYPE) {

                return DOUBLE_TYPE;

            } else if (c == Float.TYPE) {

                return FLOAT_TYPE;

            } else /* if (c == Long.TYPE) */{

                return LONG_TYPE;

            }

        } else {

            return getType(getDescriptor(c));

        }

    }

    /**

     * Returns the Java types corresponding to the argument types of the given

     * method descriptor.

     *

     * @param methodDescriptor a method descriptor.

     * @return the Java types corresponding to the argument types of the given

     *         method descriptor.

     */

    public static Type[] getArgumentTypes(final String methodDescriptor) {

        char[] buf = methodDescriptor.toCharArray();

        int off = 1;

        int size = 0;

        while (true) {

            char car = buf[off++];

            if (car == ')') {

                break;

            } else if (car == 'L') {

                while (buf[off++] != ';') {

                }

                ++size;

            } else if (car != '[') {

                ++size;

            }

        }

        Type[] args = new Type[size];

        off = 1;

        size = 0;

        while (buf[off] != ')') {

            args[size] = getType(buf, off);

            off += args[size].len + (args[size].sort == OBJECT ? 2 : 0);

            size += 1;

        }

        return args;

    }

    /**

     * Returns the Java types corresponding to the argument types of the given

     * method.

     *

     * @param method a method.

     * @return the Java types corresponding to the argument types of the given

     *         method.

     */

    public static Type[] getArgumentTypes(final Method method) {

        Class[] classes = method.getParameterTypes();

        Type[] types = new Type[classes.length];

        for (int i = classes.length - 1; i >= 0; --i) {

            types[i] = getType(classes[i]);

        }

        return types;

    }

    /**

     * Returns the Java type corresponding to the return type of the given

     * method descriptor.

     *

     * @param methodDescriptor a method descriptor.

     * @return the Java type corresponding to the return type of the given

     *         method descriptor.

     */

    public static Type getReturnType(final String methodDescriptor) {

        char[] buf = methodDescriptor.toCharArray();

        return getType(buf, methodDescriptor.indexOf(')') + 1);

    }

    /**

     * Returns the Java type corresponding to the return type of the given

     * method.

     *

     * @param method a method.

     * @return the Java type corresponding to the return type of the given

     *         method.

     */

    public static Type getReturnType(final Method method) {

        return getType(method.getReturnType());

    }

    /**

     * Returns the Java type corresponding to the given type descriptor.

     *

     * @param buf a buffer containing a type descriptor.

     * @param off the offset of this descriptor in the previous buffer.

     * @return the Java type corresponding to the given type descriptor.

     */

    private static Type getType(final char[] buf, final int off) {

        int len;

        switch (buf[off]) {

            case 'V':

                return VOID_TYPE;

            case 'Z':

                return BOOLEAN_TYPE;

            case 'C':

                return CHAR_TYPE;

            case 'B':

                return BYTE_TYPE;

            case 'S':

                return SHORT_TYPE;

            case 'I':

                return INT_TYPE;

            case 'F':

                return FLOAT_TYPE;

            case 'J':

                return LONG_TYPE;

            case 'D':

                return DOUBLE_TYPE;

            case '[':

                len = 1;

                while (buf[off + len] == '[') {

                    ++len;

                }

                if (buf[off + len] == 'L') {

                    ++len;

                    while (buf[off + len] != ';') {

                        ++len;

                    }

                }

                return new Type(ARRAY, buf, off, len + 1);

                // case 'L':

            default:

                len = 1;

                while (buf[off + len] != ';') {

                    ++len;

                }

                return new Type(OBJECT, buf, off + 1, len - 1);

        }

    }

    // ------------------------------------------------------------------------

    // Accessors

    // ------------------------------------------------------------------------

    /**

     * Returns the sort of this Java type.

     *

     * @return {@link #VOID VOID}, {@link #BOOLEAN BOOLEAN},

     *         {@link #CHAR CHAR}, {@link #BYTE BYTE}, {@link #SHORT SHORT},

     *         {@link #INT INT}, {@link #FLOAT FLOAT}, {@link #LONG LONG},

     *         {@link #DOUBLE DOUBLE}, {@link #ARRAY ARRAY} or

     *         {@link #OBJECT OBJECT}.

     */

    public int getSort() {

        return sort;

    }

    /**

     * Returns the number of dimensions of this array type. This method should

     * only be used for an array type.

     *

     * @return the number of dimensions of this array type.

     */

    public int getDimensions() {

        int i = 1;

        while (buf[off + i] == '[') {

            ++i;

        }

        return i;

    }

    /**

     * Returns the type of the elements of this array type. This method should

     * only be used for an array type.

     *

     * @return Returns the type of the elements of this array type.

     */

    public Type getElementType() {

        return getType(buf, off + getDimensions());

    }

    /**

     * Returns the name of the class corresponding to this type.

     *

     * @return the fully qualified name of the class corresponding to this type.

     */

    public String getClassName() {

        switch (sort) {

            case VOID:

                return "void";

            case BOOLEAN:

                return "boolean";

            case CHAR:

                return "char";

            case BYTE:

                return "byte";

            case SHORT:

                return "short";

            case INT:

                return "int";

            case FLOAT:

                return "float";

            case LONG:

                return "long";

            case DOUBLE:

                return "double";

            case ARRAY:

                StringBuffer b = new StringBuffer(getElementType().getClassName());

                for (int i = getDimensions(); i > 0; --i) {

                    b.append("[]");

                }

                return b.toString();

                // case OBJECT:

            default:

                return new String(buf, off, len).replace('/', '.');

        }

    }

    /**

     * Returns the internal name of the class corresponding to this object or

     * array type. The internal name of a class is its fully qualified name (as

     * returned by Class.getName(), where '.' are replaced by '/'. This method

     * should only be used for an object or array type.

     *

     * @return the internal name of the class corresponding to this object type.

     */

    public String getInternalName() {

        return new String(buf, off, len);

    }

    // ------------------------------------------------------------------------

    // Conversion to type descriptors

    // ------------------------------------------------------------------------

    /**

     * Returns the descriptor corresponding to this Java type.

     *

     * @return the descriptor corresponding to this Java type.

     */

    public String getDescriptor() {

        StringBuffer buf = new StringBuffer();

        getDescriptor(buf);

        return buf.toString();

    }

    /**

     * Returns the descriptor corresponding to the given argument and return

     * types.

     *

     * @param returnType the return type of the method.

     * @param argumentTypes the argument types of the method.

     * @return the descriptor corresponding to the given argument and return

     *         types.

     */

    public static String getMethodDescriptor(

        final Type returnType,

        final Type[] argumentTypes)

    {

        StringBuffer buf = new StringBuffer();

        buf.append('(');