/*
 * Copyright (c) 1998, 2008, Oracle and/or its affiliates. All rights reserved.
 * 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.
 */

package com.sun.tools.jdi;

import com.sun.jdi.*;

import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
import java.util.Comparator;

public abstract class MethodImpl extends TypeComponentImpl
    implements Method {
    private JNITypeParser signatureParser;
    abstract int argSlotCount() throws AbsentInformationException;

    abstract List<Location> allLineLocations(SDE.Stratum stratum,
                                   String sourceName)
                           throws AbsentInformationException;

    abstract List<Location> locationsOfLine(SDE.Stratum stratum,
                                  String sourceName,
                                  int lineNumber)
                           throws AbsentInformationException;

    MethodImpl(VirtualMachine vm, ReferenceTypeImpl declaringType,
               long ref,
               String name, String signature,
               String genericSignature, int modifiers) {
        super(vm, declaringType, ref, name, signature,
              genericSignature, modifiers);
        signatureParser = new JNITypeParser(signature);
    }

    static MethodImpl createMethodImpl(VirtualMachine vm,
                                       ReferenceTypeImpl declaringType,
                                       long ref,
                                       String name,
                                       String signature,
                                       String genericSignature,
                                       int modifiers) {
        if ((modifiers &
             (VMModifiers.NATIVE | VMModifiers.ABSTRACT)) != 0) {
            return new NonConcreteMethodImpl(vm, declaringType, ref,
                                             name, signature,
                                             genericSignature,
                                             modifiers);
        } else {
            return new ConcreteMethodImpl(vm, declaringType, ref,
                                          name, signature,
                                          genericSignature,
                                          modifiers);
        }
    }

    public boolean equals(Object obj) {
        if ((obj != null) && (obj instanceof MethodImpl)) {
            MethodImpl other = (MethodImpl)obj;
            return (declaringType().equals(other.declaringType())) &&
                   (ref() == other.ref()) &&
                   super.equals(obj);
        } else {
            return false;
        }
    }

    public int hashCode() {
        return (int)ref();
    }

    public final List<Location> allLineLocations()
                           throws AbsentInformationException {
        return allLineLocations(vm.getDefaultStratum(), null);
    }

    public List<Location> allLineLocations(String stratumID,
                                 String sourceName)
                           throws AbsentInformationException {
        return allLineLocations(declaringType.stratum(stratumID),
                                sourceName);
    }

    public final List<Location> locationsOfLine(int lineNumber)
                           throws AbsentInformationException {
        return locationsOfLine(vm.getDefaultStratum(),
                               null, lineNumber);
    }

    public List<Location> locationsOfLine(String stratumID,
                                String sourceName,
                                int lineNumber)
                           throws AbsentInformationException {
        return locationsOfLine(declaringType.stratum(stratumID),
                               sourceName, lineNumber);
    }

    LineInfo codeIndexToLineInfo(SDE.Stratum stratum,
                                 long codeIndex) {
        if (stratum.isJava()) {
            return new BaseLineInfo(-1, declaringType);
        } else {
            return new StratumLineInfo(stratum.id(), -1,
                                       null, null);
        }
    }

    
Returns:a text representation of the declared return type of this method.
/** * @return a text representation of the declared return type * of this method. */
public String returnTypeName() { return signatureParser.typeName(); } private String returnSignature() { return signatureParser.signature(); } public Type returnType() throws ClassNotLoadedException { return findType(returnSignature()); } public Type findType(String signature) throws ClassNotLoadedException { ReferenceTypeImpl enclosing = (ReferenceTypeImpl)declaringType(); return enclosing.findType(signature); } public List<String> argumentTypeNames() { return signatureParser.argumentTypeNames(); } public List<String> argumentSignatures() { return signatureParser.argumentSignatures(); } Type argumentType(int index) throws ClassNotLoadedException { ReferenceTypeImpl enclosing = (ReferenceTypeImpl)declaringType(); String signature = argumentSignatures().get(index); return enclosing.findType(signature); } public List<Type> argumentTypes() throws ClassNotLoadedException { int size = argumentSignatures().size(); ArrayList<Type> types = new ArrayList<Type>(size); for (int i = 0; i < size; i++) { Type type = argumentType(i); types.add(type); } return types; } public int compareTo(Method method) { ReferenceTypeImpl declaringType = (ReferenceTypeImpl)declaringType(); int rc = declaringType.compareTo(method.declaringType()); if (rc == 0) { rc = declaringType.indexOf(this) - declaringType.indexOf(method); } return rc; } public boolean isAbstract() { return isModifierSet(VMModifiers.ABSTRACT); } public boolean isSynchronized() { return isModifierSet(VMModifiers.SYNCHRONIZED); } public boolean isNative() { return isModifierSet(VMModifiers.NATIVE); } public boolean isVarArgs() { return isModifierSet(VMModifiers.VARARGS); } public boolean isBridge() { return isModifierSet(VMModifiers.BRIDGE); } public boolean isConstructor() { return name().equals("<init>"); } public boolean isStaticInitializer() { return name().equals("<clinit>"); } public boolean isObsolete() { try { return JDWP.Method.IsObsolete.process(vm, declaringType, ref).isObsolete; } catch (JDWPException exc) { throw exc.toJDIException(); } } /* * A container class for the return value to allow * proper type-checking. */ class ReturnContainer implements ValueContainer { ReturnContainer() { } public Type type() throws ClassNotLoadedException { return returnType(); } public String typeName(){ return returnTypeName(); } public String signature() { return returnSignature(); //type().signature(); } public Type findType(String signature) throws ClassNotLoadedException { return MethodImpl.this.findType(signature); } } ReturnContainer retValContainer = null; ReturnContainer getReturnValueContainer() { if (retValContainer == null) { retValContainer = new ReturnContainer(); } return retValContainer; } /* * A container class for the argument to allow * proper type-checking. */ class ArgumentContainer implements ValueContainer { int index; ArgumentContainer(int index) { this.index = index; } public Type type() throws ClassNotLoadedException { return argumentType(index); } public String typeName(){ return argumentTypeNames().get(index); } public String signature() { return argumentSignatures().get(index); } public Type findType(String signature) throws ClassNotLoadedException { return MethodImpl.this.findType(signature); } } /* * This is a var args method. Thus, its last param is an * array. If the method has n params, then: * 1. If there are n args and the last is the same type as the type of * the last param, do nothing. IE, a String[] * can be passed to a String... * 2. If there are >= n arguments and for each arg whose number is >= n, * the arg type is 'compatible' with the component type of * the last param, then do * - create an array of the type of the last param * - put the n, ... args into this array. * We might have to do conversions here. * - put this array into arguments(n) * - delete arguments(n+1), ... * NOTE that this might modify the input list. */ void handleVarArgs(List<Value> arguments) throws ClassNotLoadedException, InvalidTypeException { List<Type> paramTypes = this.argumentTypes(); ArrayType lastParamType = (ArrayType)paramTypes.get(paramTypes.size() - 1); Type componentType = lastParamType.componentType(); int argCount = arguments.size(); int paramCount = paramTypes.size(); if (argCount < paramCount - 1) { // Error; will be caught later. return; } if (argCount == paramCount - 1) { // It is ok to pass 0 args to the var arg. // We have to gen a 0 length array. ArrayReference argArray = lastParamType.newInstance(0); arguments.add(argArray); return; } Value nthArgValue = arguments.get(paramCount - 1); if (nthArgValue == null) { return; } Type nthArgType = nthArgValue.type(); if (nthArgType instanceof ArrayTypeImpl) { if (argCount == paramCount && ((ArrayTypeImpl)nthArgType).isAssignableTo(lastParamType)) { /* * This is case 1. A compatible array is being passed to the * var args array param. We don't have to do anything. */ return; } } /* * Case 2. We have to verify that the n, n+1, ... args are compatible * with componentType, and do conversions if necessary and create * an array of componentType to hold these possibly converted values. */ int count = argCount - paramCount + 1; ArrayReference argArray = lastParamType.newInstance(count); /* * This will copy arguments(paramCount - 1) ... to argArray(0) ... * doing whatever conversions are needed! It will throw an * exception if an incompatible arg is encountered */ argArray.setValues(0, arguments, paramCount - 1, count); arguments.set(paramCount - 1, argArray); /* * Remove the excess args */ for (int ii = paramCount; ii < argCount; ii++) { arguments.remove(paramCount); } return; } /* * The output list will be different than the input list. */ List<Value> validateAndPrepareArgumentsForInvoke(List<? extends Value> origArguments) throws ClassNotLoadedException, InvalidTypeException { List<Value> arguments = new ArrayList<Value>(origArguments); if (isVarArgs()) { handleVarArgs(arguments); } int argSize = arguments.size(); JNITypeParser parser = new JNITypeParser(signature()); List signatures = parser.argumentSignatures(); if (signatures.size() != argSize) { throw new IllegalArgumentException("Invalid argument count: expected " + signatures.size() + ", received " + arguments.size()); } for (int i = 0; i < argSize; i++) { Value value = arguments.get(i); value = ValueImpl.prepareForAssignment(value, new ArgumentContainer(i)); arguments.set(i, value); } return arguments; } public String toString() { StringBuffer sb = new StringBuffer(); sb.append(declaringType().name()); sb.append("."); sb.append(name()); sb.append("("); boolean first = true; for (String name : argumentTypeNames()) { if (!first) { sb.append(", "); } sb.append(name); first = false; } sb.append(")"); return sb.toString(); } }