deep-c-rsc/JCGO/jtrsrc/com/ivmaisoft/jcgo/MethodDefinition.java

/*
 * @(#) $(JCGO)/jtrsrc/com/ivmaisoft/jcgo/MethodDefinition.java --
 * a part of JCGO translator.
 **
 * Project: JCGO (http://www.ivmaisoft.com/jcgo/)
 * Copyright (C) 2001-2012 Ivan Maidanski <ivmai@mail.ru>
 * All rights reserved.
 */

/*
 * This is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 **
 * This software 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 (GPL) for more details.
 **
 * Linking this library statically or dynamically with other modules is
 * making a combined work based on this library. Thus, the terms and
 * conditions of the GNU General Public License cover the whole
 * combination.
 **
 * As a special exception, the copyright holders of this library give you
 * permission to link this library with independent modules to produce an
 * executable, regardless of the license terms of these independent
 * modules, and to copy and distribute the resulting executable under
 * terms of your choice, provided that you also meet, for each linked
 * independent module, the terms and conditions of the license of that
 * module. An independent module is a module which is not derived from
 * or based on this library. If you modify this library, you may extend
 * this exception to your version of the library, but you are not
 * obligated to do so. If you do not wish to do so, delete this
 * exception statement from your version.
 */

package com.ivmaisoft.jcgo;

import java.util.Enumeration;

/**
 * A method entity definition.
 */

final class MethodDefinition {

    static/* final */int MAX_INLINE = 10;

    static final String UNKNOWN_NAME = "<unknown?>".toString();

    static final String STACKOBJ_RETNAME = "jcgo_stackparam".toString();

    private static final ObjVector EMPTY_VECTOR = new ObjVector();

    private final OrderedMap fieldDictionary = new OrderedMap();

    private ClassDefinition ourClass;

    private ExpressionType resType;

    private ExpressionType actualType;

    private Term paramList;

    private ObjVector thrownClasses;

    private Term body;

    private String id;

    private MethodSignature ourSig;

    private int modifiers;

    private MethodDefinition singleCaller;

    private int returnsCnt;

    private boolean copied;

    private boolean used;

    private boolean usedExact;

    private boolean allUsed;

    private boolean innerUsed;

    private boolean isNewUsed;

    private boolean outputDone;

    private boolean referenced;

    private boolean newReferenced;

    private boolean analysisBegin;

    private boolean analysisDone;

    private BranchContext methodBranch;

    private MethodInvocation classNewInstanceCall;

    private MethodSignature constructorInstanceSign;

    private ExpressionType classLiteralValue;

    private boolean needsTrigClinit;

    private boolean needsDummyRet;

    private boolean isVirtual;

    private boolean isNullReturned;

    private boolean leaksDiscoverProcessing;

    private ObjVector retWritableArrays;

    private Term stackObjRetTerm;

    private boolean leaksDiscoverDone;

    private boolean stackObjRetRequired;

    private boolean hasThisObjLeak;

    private boolean hasThisObjRet;

    private boolean isThisStackObjVolatile;

    private int nextLabel;

    private MethodDefinition helperMethod;

    private ExpressionType curTraceType;

    MethodDefinition(ClassDefinition ourClass) {
        this.ourClass = ourClass;
        id = "<clinit>";
        modifiers = AccModifier.STATIC;
        resType = Main.dict.classTable[Type.VOID];
        paramList = Empty.newTerm();
        body = Empty.newTerm();
        thrownClasses = EMPTY_VECTOR;
    }

    MethodDefinition(Context c, String id, int modifiers,
            ExpressionType resType, Term paramList, Term throwsList, Term body) {
        ourClass = c.currentClass;
        this.id = id;
        if ((modifiers & (AccModifier.PRIVATE | AccModifier.PROTECTED | AccModifier.PUBLIC)) == (AccModifier.PRIVATE | AccModifier.PROTECTED)) {
            modifiers &= ~(AccModifier.PRIVATE | AccModifier.PROTECTED);
        }
        this.modifiers = modifiers;
        this.resType = resType;
        this.paramList = paramList;
        this.body = body;
        Term.assertCond(c.currentClass != null);
        Term.assertCond(c.currentMethod == null);
        if (ourClass.isInterface() && !isClassMethod()) {
            this.modifiers |= AccModifier.PUBLIC | AccModifier.ABSTRACT;
        }
        if (!isAbstract() && !isNative()) {
            Main.dict.methodsAnalyzed++;
        }
        c.currentMethod = this;
        paramList.processPass1(c);
        c.currentMethod = null;
        thrownClasses = EMPTY_VECTOR;
        if (throwsList.notEmpty()) {
            throwsList.processPass1(c);
            thrownClasses = throwsList.getSignature();
        }
    }

    private MethodDefinition(ClassDefinition ourClass, String id,
            int modifiers, ExpressionType resType, Term paramList,
            ObjVector thrownClasses, Term body, boolean copied) {
        this.ourClass = ourClass;
        this.id = id;
        this.modifiers = modifiers;
        this.resType = resType;
        this.paramList = paramList;
        this.thrownClasses = thrownClasses;
        this.body = body;
        this.copied = copied;
    }

    MethodDefinition cloneMethodFor(ClassDefinition ourClass,
            boolean isProxyClass) {
        return new MethodDefinition(ourClass, id,
                isProxyClass ? AccModifier.PUBLIC | AccModifier.FINAL
                        | AccModifier.SYNTHETIC : modifiers, resType,
                paramList, isProxyClass ? copyCheckedExceptions(ourClass)
                        : thrownClasses, new Block(), !isProxyClass);
    }

    private ObjVector copyCheckedExceptions(ClassDefinition forClass) {
        int size = thrownClasses.size();
        ObjVector newThrownClasses = thrownClasses;
        if (size > 0) {
            newThrownClasses = new ObjVector();
            for (int i = 0; i < size; i++) {
                ClassDefinition cd = (ClassDefinition) thrownClasses
                        .elementAt(i);
                if (!cd.isUncheckedException(forClass)) {
                    boolean found = false;
                    int j = newThrownClasses.size();
                    while (j-- > 0) {
                        ClassDefinition cd2 = (ClassDefinition) newThrownClasses
                                .elementAt(j);
                        if (cd2.isAssignableFrom(cd, 0, forClass)) {
                            found = true;
                            break;
                        }
                        if (cd.isAssignableFrom(cd2, 0, forClass)) {
                            newThrownClasses.removeElementAt(j);
                        }
                    }
                    if (!found) {
                        newThrownClasses.addElement(cd);
                    }
                }
            }
        }
        return newThrownClasses;
    }

    void intersectThrowsWith(MethodDefinition md2) {
        int i = thrownClasses.size();
        while (i-- > 0) {
            ClassDefinition cd = (ClassDefinition) thrownClasses.elementAt(i);
            if (md2.thrownClasses.size() <= i
                    || md2.thrownClasses.elementAt(i) != cd) {
                ClassDefinition maxClass = null;
                Enumeration en = md2.thrownClassesElements();
                while (en.hasMoreElements()) {
                    ClassDefinition cd2 = (ClassDefinition) en.nextElement();
                    if (cd2.isAssignableFrom(cd, 0, ourClass)) {
                        maxClass = cd;
                        break;
                    }
                    if (cd.isAssignableFrom(cd2, 0, ourClass)
                            && (maxClass == null || cd2.isAssignableFrom(
                                    maxClass, 0, ourClass))) {
                        maxClass = cd2;
                    }
                }
                if (maxClass != null) {
                    thrownClasses.setElementAt(maxClass, i);
                } else {
                    thrownClasses.removeElementAt(i);
                }
            }
        }
    }

    boolean hasSameThrows(MethodDefinition md2) {
        int size = thrownClasses.size();
        if (md2.thrownClasses.size() != size)
            return false;
        for (int i = 0; i < size; i++) {
            if (thrownClasses.elementAt(i) != md2.thrownClasses.elementAt(i))
                return false;
        }
        return true;
    }

    Enumeration thrownClassesElements() {
        return thrownClasses.elements();
    }

    boolean hasNonEmptyBody() {
        Term.assertCond(analysisDone);
        return body.tokenCount() != 0;
    }

    String id() {
        return id;
    }

    ClassDefinition definingClass() {
        return ourClass;
    }

    void setVirtual() {
        if (!isVirtual && used && allowVirtual()) {
            isVirtual = true;
            if (!isFinal()) {
                ourClass.setVirtualInSubclasses(methodSignature()
                        .signatureString());
            }
        }
    }

    boolean isCopiedFromIface() {
        return copied;
    }

    int markUsed(MethodDefinition callerMethod) {
        incCallsCount(callerMethod);
        String className = ourClass.name();
        return markUsed(ourClass, className.equals(Names.JAVA_LANG_CLASS)
                || className.equals(Names.JAVA_LANG_STRING));
    }

    int markUsed(ClassDefinition receiverClass, boolean isClinitSafe) {
        if (!isClinitSafe) {
            needsTrigClinit = true;
        }
        int cnt = 0;
        if (!allUsed) {
            if (isClassMethod() || isConstructor()) {
                cnt = markUsedThisOnly();
            } else if (!ourClass.hasInstances()) {
                if (!innerUsed) {
                    innerUsed = true;
                    cnt = 1;
                }
            } else if (!isAbstract() && allowOverride()
                    && !ourClass.hasExactInstance()
                    && ourClass.overriddenByAllUsed(this)) {
                if (!innerUsed) {
                    innerUsed = true;
                    cnt = 1;
                    used = true;
                }
            } else {
                cnt = markUsedThisOnly();
            }
            if (!isConstructor() && allowOverride()) {
                cnt += receiverClass.markMethodInSubclasses(methodSignature()
                        .signatureString(), isProtectedOrPublic() ? null
                        : ourClass.getPackageName());
                if (receiverClass == ourClass) {
                    allUsed = true;
                }
            }
        }
        return cnt;
    }

    int markUsedThisOnly() {
        if (usedExact)
            return 0;
        String ourClassName = ourClass.name();
        if (id.equals(Main.dict.failOnMethodId)
                && (Main.dict.failOnClassName == null || ourClassName
                        .equals(Main.dict.failOnClassName)))
            throw new AssertException("Specified method is required!");
        ourClass.markUsed();
        usedExact = true;
        used = true;
        if (isNative()) {
            markAllTypes(false);
        }
        if (isConstructor()) {
            if (!ourClass.isAbstractOrInterface()) {
                ourClass.setHasInstances();
            }
            if (!hasParameters() && !isPrivate()) {
                ourClass.setHasExactInstance(true);
            }
        }
        resType.signatureClass().predefineClass(ourClass);
        if (ourClassName.equals(Names.JAVA_LANG_CLASS)) {
            if (isExactMatch(false, Names.JAVA_LANG_CLASS, 1,
                    Names.SIGN_GETINTERFACES)) {
                ClassDefinition.markAllDirectIfaces();
            }
        } else if (ourClassName.equals(Names.JAVA_LANG_VMTHREAD)) {
            Main.dict.markInitSystemErr();
        } else if (ourClassName.equals(Names.JAVA_LANG_ENUM)
                && isExactMatch(true, Names.JAVA_LANG_ENUM, 0,
                        Names.SIGN_VALUEOF_ENUM)) {
            ClassDefinition.processEnumValueOf();
        }
        return 1;
    }

    void markNew() {
        if (!isNewUsed) {
            isNewUsed = true;
            ourClass.setHasExactInstance(true);
        }
    }

    void markAllTypes(boolean vTableUsed) {
        ClassDefinition cd = resType.signatureClass();
        cd.define(ourClass);
        if (vTableUsed) {
            cd.setVTableUsed(true);
        } else {
            cd.markUsed();
        }
        Enumeration en = methodSignature().elements();
        while (en.hasMoreElements()) {
            cd = ((ExpressionType) en.nextElement()).signatureClass();
            cd.predefineClass(ourClass);
            if (vTableUsed) {
                cd.setVTableUsed(true);
            } else {
                cd.markUsed();
            }
        }
        Enumeration en2 = thrownClasses.elements();
        while (en2.hasMoreElements()) {
            cd = (ClassDefinition) en2.nextElement();
            cd.predefineClass(ourClass);
            if (vTableUsed) {
                cd.setVTableUsed(true);
            } else {
                cd.markUsed();
            }
        }
    }

    void checkMarkedUsed() {
        if (innerUsed) {
            if (used) {
                if (!usedExact
                        && (ourClass.hasExactInstance() || !ourClass
                                .overriddenByAllUsed(this))) {
                    markUsedThisOnly();
                }
            } else if (ourClass.hasInstances()) {
                if (!isAbstract() && allowOverride()
                        && !ourClass.hasExactInstance()
                        && ourClass.overriddenByAllUsed(this)) {
                    used = true;
                } else {
                    markUsedThisOnly();
                }
            }
        }
    }

    void incCallsCount(MethodDefinition callerMethod) {
        singleCaller = singleCaller == null && callerMethod != null ? callerMethod
                : this;
        if (callerMethod != null && callerMethod.definingClass() == ourClass) {
            if (callerMethod != this) {
                ourClass.addInclassCall(this);
            } else {
                referenced = true;
            }
        }
    }

    String nextLabelSuffix() {
        return Integer
                .toString(id.equals("<clinit>") ? ++ourClass.nextClinitLabel
                        : id.equals("<init0>") ? ++ourClass.nextInitZLabel
                                : ++nextLabel);
    }

    boolean used() {
        return used;
    }

    boolean usedExact() {
        return usedExact;
    }

    int getJavaModifiers() {
        return modifiers;
    }

    boolean isConstructor() {
        return id.equals("<init>");
    }

    boolean isAbstract() {
        return (modifiers & AccModifier.ABSTRACT) != 0;
    }

    boolean isClassMethod() {
        return (modifiers & AccModifier.STATIC) != 0;
    }

    boolean isFinal() {
        return (modifiers & AccModifier.FINAL) != 0;
    }

    boolean isNative() {
        return (modifiers & AccModifier.NATIVE) != 0;
    }

    boolean isSynchronized() {
        return (modifiers & AccModifier.SYNCHRONIZED) != 0;
    }

    boolean isPrivate() {
        return (modifiers & AccModifier.PRIVATE) != 0;
    }

    boolean isPublic() {
        return (modifiers & AccModifier.PUBLIC) != 0;
    }

    boolean isProtectedOrPublic() {
        return (modifiers & (AccModifier.PUBLIC | AccModifier.PROTECTED)) != 0;
    }

    boolean allowVirtual() {
        return (modifiers & (AccModifier.PRIVATE | AccModifier.STATIC)) == 0
                && !isConstructor();
    }

    boolean allowOverride() {
        return (modifiers & (AccModifier.PRIVATE | AccModifier.STATIC | AccModifier.FINAL)) == 0
                && !ourClass.isFinal();
    }

    boolean isGetterSetter() {
        if (isClassMethod())
            return false;
        int s1 = resType.objectSize();
        return id.startsWith("get") ? s1 != Type.VOID && !paramList.notEmpty()
                : id.startsWith("is") ? s1 == Type.BOOLEAN && id.length() > 2
                        && !paramList.notEmpty() : id.startsWith("set")
                        && (s1 == Type.VOID || s1 == Type.BOOLEAN)
                        && paramList.tokenCount() == 1;
    }

    Term copyParamList(int skipHeadCnt, int skipTailCnt) {
        int[] skip = new int[2];
        skip[1] = (skip[0] = methodSignature().paramCount() - skipTailCnt)
                - skipHeadCnt;
        return paramList.copyParamList(skip);
    }

    private MethodDefinition replaceMethodEntry() {
        if (!isNative()) {
            MethodDefinition md = body.superMethodCall();
            if (md != null && md != this && md.usedExact()
                    && !md.hasParameters() && resType == md.resType
                    && !md.isClassMethod() && !md.isAbstract()
                    && md.isSynchronized() == isSynchronized())
                return md.replaceMethodEntry();
        }
        return this;
    }

    ExpressionType exprType() {
        return resType;
    }

    ExpressionType actualExprType() {
        if (actualType != null)
            return analysisDone ? actualType : resType;
        int s1;
        if (!usedExact
                || isConstructor()
                || ((s1 = resType.objectSize()) != Type.CLASSINTERFACE && s1 != Type.OBJECTARRAY))
            return resType;
        if (isAbstract()) {
            actualType = resType;
            return actualType;
        }
        producePassOne(null);
        return actualType != null ? actualType : resType;
    }

    void setActualType(ExpressionType actual, Term t) {
        Term.assertCond(analysisBegin);
        returnsCnt++;
        int s0 = actual.objectSize();
        if (s0 == Type.NULLREF || s0 >= Type.CLASSINTERFACE) {
            if (actualType != null) {
                actualType = ClassDefinition.maxCommonExprOf(actualType,
                        actual, ourClass);
                if (!ClassDefinition.isAssignableFrom(resType, actualType,
                        ourClass)) {
                    actualType = resType;
                }
            } else {
                actualType = actual;
            }
            if (s0 == Type.NULLREF || !t.isNotNull()) {
                isNullReturned = true;
            }
        }
        if (s0 == Type.CLASSINTERFACE) {
            if (classNewInstanceCall == null) {
                classNewInstanceCall = t.getClassNewInstanceCall();
            }
            if (constructorInstanceSign == null) {
                constructorInstanceSign = t.getConstructorInstanceSign();
            }
            if (classLiteralValue == null
                    && (resType.name().equals(Names.JAVA_LANG_CLASS) || resType
                            .receiverClass().superClass() == null)) {
                classLiteralValue = t.classLiteralValGuess();
            }
        }
    }

    boolean isNotNull() {
        if (!usedExact || isConstructor() || isAbstract()
                || resType.objectSize() < Type.CLASSINTERFACE)
            return false;
        producePassOne(null);
        return !isNullReturned && actualType != null && analysisDone;
    }

    void resetLocalsActualType(Context c, ObjQueue names, boolean forTry) {
        Enumeration en = names.elements();
        while (en.hasMoreElements()) {
            VariableDefinition v = getLocalVar((String) en.nextElement());
            if (v != null) {
                c.resetVarForLoopOrTry(v);
                if (!forTry) {
                    v.resetTypeForLoop();
                }
            }
        }
    }

    MethodInvocation getClassNewInstanceCall() {
        if (!usedExact || isConstructor() || isAbstract()
                || resType.objectSize() != Type.CLASSINTERFACE)
            return null;
        producePassOne(null);
        return classNewInstanceCall;
    }

    MethodSignature getConstructorInstanceSign() {
        if (!usedExact || isConstructor() || isAbstract()
                || resType.objectSize() != Type.CLASSINTERFACE)
            return null;
        producePassOne(null);
        return constructorInstanceSign;
    }

    ExpressionType classLiteralValGuess() {
        if (!usedExact || isConstructor() || isAbstract()
                || resType.objectSize() != Type.CLASSINTERFACE)
            return null;
        producePassOne(null);
        return classLiteralValue;
    }

    String getJavaSignature() {
        return methodSignature().getJavaSignature()
                + (isConstructor() ? Type.sig[Type.VOID] : resType
                        .getJavaSignature());
    }

    MethodSignature methodSignature() {
        if (ourSig == null) {
            ourSig = new MethodSignature(id, paramList.getSignature());
        }
        return ourSig;
    }

    boolean needsTrigClinit() {
        Term.assertCond(used);
        return needsTrigClinit;
    }

    String newRoutineCName() {
        Term.assertCond(used && isConstructor());
        newReferenced = true;
        return ourClass.routineNameOf(methodSignature().csignForNew(ourClass));
    }

    String routineCName() {
        Term.assertCond(usedExact);
        referenced = true;
        return ourClass.routineNameOf(csign());
    }

    String stackObjRetRoutineCName() {
        Term.assertCond(stackObjRetRequired);
        referenced = true;
        return ourClass.routineNameOf(csign()) + "X";
    }

    String csign() {
        return methodSignature()
                .csign(allowVirtual() && !ourClass.isInterface() ? ourClass
                        : null,
                        isClassMethod() || isConstructor() ? ourClass
                                .castName() : null);
    }

    boolean isExactMatch(boolean isStatic, String exprTypeName,
            int exprTypeDims, String sigString) {
        return isClassMethod() == isStatic
                && resType.signatureDimensions() == exprTypeDims
                && resType.signatureClass().name().equals(exprTypeName)
                && methodSignature().signatureString().equals(sigString);
    }

    boolean addLocalVariable(VariableDefinition v) {
        return fieldDictionary.put(v.id(), v) == null;
    }

    VariableDefinition getLocalVar(String name) {
        return (VariableDefinition) fieldDictionary.get(name);
    }

    Enumeration getLocalsNames() {
        return fieldDictionary.keys();
    }

    void delLocalVar(String name) {
        fieldDictionary.remove(name);
    }

    private void locateHelperMethod() {
        ClassDefinition helperClass = ourClass.getReflectHelperClass();
        if (helperClass != null) {
            helperClass.define(ourClass);
            if (id.equals("<clinit>")) {
                helperMethod = helperClass
                        .getMethodNoInheritance(new MethodSignature("_clinit",
                                EMPTY_VECTOR));
            } else {
                helperMethod = helperClass
                        .getMethodNoInheritance(methodSignature());
                if (helperMethod == null) {
                    helperMethod = helperClass
                            .getMethodNoInheritance(new MethodSignature(id,
                                    EMPTY_VECTOR));
                    if (helperMethod == null && isNative()) {
                        helperMethod = helperClass
                                .getMethodNoInheritance(new MethodSignature(
                                        "_native", EMPTY_VECTOR));
                    }
                    if (helperMethod == null) {
                        helperMethod = helperClass
                                .getMethodNoInheritance(new MethodSignature(
                                        "_", EMPTY_VECTOR));
                    }
                }
            }
        }
    }

    private int initForceVmExc() {
        int forceVmExc = 0;
        Enumeration en = thrownClasses.elements();
        while (en.hasMoreElements()) {
            forceVmExc |= ((ClassDefinition) en.nextElement()).getVMExcMask();
        }
        return forceVmExc;
    }

    BranchContext producePassOne(BranchContext prevBranch) {
        Term.assertCond(ourClass != null);
        if (analysisBegin)
            return null;
        analysisBegin = true;
        Context c = ourClass.cloneContextFor(this);
        if (isSynchronized() && !isNative()) {
            body = new SynchroMethod(body);
        }
        Term.assertCond(c.currentClass == ourClass && c.currentMethod == this);
        locateHelperMethod();
        c.forceVmExc = initForceVmExc();
        if (helperMethod != null) {
            c.forceVmExc |= helperMethod.initForceVmExc();
        }
        c.initBranch();
        if (prevBranch != null) {
            c.unionBranchExceptLocals(prevBranch, !isClassMethod());
        }
        body.processPass1(c);
        if (methodBranch == null || resType.objectSize() == Type.VOID
                || isConstructor()) {
            setMethodBranchFrom(c);
        }
        if (helperMethod != null && prevBranch == null)
            helperMethod.producePassOne(null);
        analysisDone = true;
        return methodBranch;
    }

    void setMethodBranchFrom(Context c) {
        Term.assertCond(analysisBegin && !analysisDone);
        if (methodBranch != null) {
            BranchContext otherBranch = c.swapBranch(methodBranch);
            c.intersectBranch(otherBranch);
            methodBranch = c.swapBranch(otherBranch);
        } else {
            methodBranch = c.saveBranch();
        }
    }

    void processBranch(Context c, boolean isThis) {
        if (usedExact) {
            producePassOne(null);
            if (analysisDone) {
                c.unionBranchExceptLocals(methodBranch, isThis);
            }
        }
    }

    boolean isBranchVarNotNull(VariableDefinition v) {
        if (!analysisDone)
            return false;
        Term.assertCond(v != null);
        return methodBranch.nonNullVars.identityLastIndexOf(v) >= 0;
    }

    ExpressionType getBranchActualType(VariableDefinition v) {
        if (!analysisDone)
            return null;
        Term.assertCond(v != null);
        return methodBranch.getActualType(v);
    }

    void setArgsFormalType(Term actualParamList, Context c) {
        actualParamList.setFormalType(paramList, this, c);
    }

    void setNeedsDummyRet() {
        needsDummyRet = true;
    }

    boolean hasParameters() {
        return paramList.notEmpty();
    }

    boolean isFirstParamUsed() {
        Term t = paramList.getArgumentTerm(0);
        Term.assertCond(t != null);
        VariableDefinition v = getLocalVar(t.dottedName());
        Term.assertCond(v != null);
        return v.used();
    }

    boolean discoverObjLeaks() {
        if (leaksDiscoverProcessing)
            return false;
        Term.assertCond(usedExact);
        if (ourClass.isProxyClass()) {
            leaksDiscoverDone = true;
            return false;
        }
        boolean isArrayCopy = false;
        if (isNative()) {
            if (!ourClass.name().equals(Names.JAVA_LANG_VMOBJECT)
                    || !isExactMatch(true, Names.JAVA_LANG_OBJECT, 0,
                            Names.SIGN_CLONE0)) {
                if (!isClassMethod()
                        || !ourClass.name().equals(Names.JAVA_LANG_VMSYSTEM)
                        || resType.objectSize() != Type.VOID
                        || !methodSignature().signatureString().equals(
                                Names.SIGN_ARRAYCOPY)) {
                    leaksDiscoverDone = true;
                    return false;
                }
                isArrayCopy = true;
            }
        }
        if (!leaksDiscoverDone) {
            ObjQueue oldStackObjRetCalls = Main.dict.stackObjRetCalls;
            Main.dict.stackObjRetCalls = new ObjQueue();
            leaksDiscoverProcessing = true;
            MethodDefinition oldOurMethod = Main.dict.ourMethod;
            Main.dict.ourMethod = this;
            ObjHashtable oldAssignedLocals = Main.dict.assignedLocals;
            Main.dict.assignedLocals = new ObjHashtable();
            paramList.discoverObjLeaks();
            if (isArrayCopy) {
                paramList.getTermAt(1).getTermAt(1).getTermAt(0)
                        .setObjLeaks(VariableDefinition.WRITABLE_ARRAY_VAR);
            }
            body.discoverObjLeaks();
            Main.dict.assignedLocals = oldAssignedLocals;
            leaksDiscoverDone = true;
            setRequiredStackObjRets(Main.dict.stackObjRetCalls);
            leaksDiscoverProcessing = false;
            Main.dict.ourMethod = oldOurMethod;
            Main.dict.stackObjRetCalls = oldStackObjRetCalls;
        }
        return true;
    }

    boolean copyObjLeaksTo(Term argsList) {
        if (!usedExact)
            return false;
        if (!leaksDiscoverProcessing && !leaksDiscoverDone && isClassMethod()) {
            ObjVector parmSig = new ObjVector();
            paramList.storeSignature(parmSig);
            int i = parmSig.size();
            while (i-- > 0) {
                if (((ExpressionType) parmSig.elementAt(i)).objectSize() >= Type.CLASSINTERFACE)
                    break;
            }
            if (i < 0)
                return true;
        }
        return argsList.copyObjLeaksFrom(discoverObjLeaks() ? paramList : null);
    }

    void setThisObjLeak(boolean isReturned) {
        Term.assertCond(leaksDiscoverProcessing);
        if (isReturned) {
            hasThisObjRet = true;
        } else {
            hasThisObjLeak = true;
        }
    }

    boolean hasThisObjLeak(boolean isReturned) {
        if (isClassMethod() || !usedExact)
            return false;
        if (!discoverObjLeaks())
            return !isReturned;
        return isReturned ? hasThisObjRet && !hasThisObjLeak : hasThisObjLeak;
    }

    void setThisStackObjVolatile() {
        Term.assertCond(leaksDiscoverProcessing);
        isThisStackObjVolatile = true;
    }

    boolean isThisStackObjVolatile() {
        return isThisStackObjVolatile;
    }

    boolean attachRetWritableArray(VariableDefinition v) {
        Term.assertCond(leaksDiscoverProcessing && !isConstructor()
                && resType.objectSize() >= Type.CLASSINTERFACE);
        if (retWritableArrays == EMPTY_VECTOR)
            return false;
        if (retWritableArrays == null) {
            retWritableArrays = new ObjVector();
        }
        if (retWritableArrays.identityLastIndexOf(v) < 0) {
            retWritableArrays.addElement(v);
        }
        return true;
    }

    void setWritableArray() {
        Term.assertCond(resType.objectSize() >= Type.CLASSINTERFACE);
        if (retWritableArrays != EMPTY_VECTOR) {
            if (retWritableArrays != null) {
                Enumeration en = retWritableArrays.elements();
                retWritableArrays = EMPTY_VECTOR;
                while (en.hasMoreElements()) {
                    ((VariableDefinition) en.nextElement())
                            .setWritableArray(null);
                }
            } else {
                retWritableArrays = EMPTY_VECTOR;
            }
        }
    }

    void setStackObjRetTerm(Term t) {
        Term.assertCond(leaksDiscoverProcessing && !isConstructor()
                && resType.objectSize() >= Type.CLASSINTERFACE);
        if (stackObjRetTerm == null) {
            stackObjRetTerm = t;
        }
    }

    void attachStackObjRetTerm(VariableDefinition v, Term t) {
        Term.assertCond(leaksDiscoverProcessing);
        if (stackObjRetTerm == t && (v == null || !v.addSetObjLeaksTerm(t))) {
            stackObjRetTerm = null;
        }
    }

    boolean allowStackObjRet() {
        return (!usedExact || (returnsCnt == 1
                && resType.objectSize() >= Type.CLASSINTERFACE
                && discoverObjLeaks() && stackObjRetTerm != null))
                && !isVMSpecialMethod();
    }

    static void setRequiredStackObjRets(ObjQueue stackObjRetCalls) {
        Enumeration en = stackObjRetCalls.elements();
        while (en.hasMoreElements()) {
            MethodDefinition md = ((MethodInvocation) en.nextElement())
                    .getNoLeaksScopeMethod();
            while (md != null && !md.stackObjRetRequired) {
                Term t = md.stackObjRetTerm;
                Term.assertCond(t != null);
                md.stackObjRetRequired = true;
                md = t.stackObjRetMethodCall();
            }
        }
    }

    boolean stackObjRetRequired() {
        if (!usedExact)
            return true;
        Term.assertCond(leaksDiscoverDone && stackObjRetTerm != null);
        return stackObjRetRequired;
    }

    String writeStackObjDefn(OutputContext oc, boolean needsLocalVolatile) {
        if (!usedExact)
            return null;
        Term.assertCond(!leaksDiscoverProcessing && leaksDiscoverDone
                && stackObjRetTerm != null && stackObjRetRequired);
        return stackObjRetTerm.writeStackObjDefn(oc, needsLocalVolatile);
    }

    void writeStackObjTrigClinit(OutputContext oc) {
        Term.assertCond(stackObjRetTerm != null);
        stackObjRetTerm.writeStackObjTrigClinit(oc);
    }

    ExpressionType writeStackObjRetCode(OutputContext oc) {
        Term.assertCond(!leaksDiscoverProcessing && leaksDiscoverDone
                && stackObjRetTerm != null && stackObjRetRequired);
        return stackObjRetTerm.writeStackObjRetCode(oc);
    }

    boolean allowInline() {
        if (isConstructor())
            return (hasParameters() && allowSingleInline())
                    || allowBodyInline();
        if (isNative())
            return allowSingleInline() && !Names.isVMCoreClass(ourClass.name());
        return ((!isClassMethod() && !ourClass.hasRealInstances())
                || allowSingleInline() || (allowBodyInline() && !ourClass
                .isProxyClass())) && !isVMSpecialMethod();
    }

    private boolean allowBodyInline() {
        return body.allowInline(paramList.tokenCount()
                + MAX_INLINE
                + (isClassMethod() || isConstructor() ? (needsTrigClinit
                        && ourClass.classInitializerNotCalledYet() ? -2 : 0)
                        : 1)
                - (isSynchronized() && resType.objectSize() != Type.VOID ? 2
                        : 0));
    }

    private boolean allowSingleInline() {
        return !isVirtual
                && hasSingleCaller()
                && (singleCaller.hasSingleCaller()
                        || singleCaller.id.equals("<clinit>") || !singleCaller
                        .allowInline());
    }

    private boolean hasSingleCaller() {
        return singleCaller != null && singleCaller != this;
    }

    private boolean isVMSpecialMethod() {
        if (ourClass.name().equals(Names.JAVA_LANG_OBJECT)
                && !isClassMethod()
                && resType.objectSize() == Type.VOID
                && methodSignature().signatureString().equals(
                        Names.SIGN_FINALIZE))
            return true;
        int pos = id.length();
        char ch;
        if (pos > 2 && (id.charAt(pos - 1) != 'X' || --pos > 2)
                && id.charAt(pos - 1) == '0'
                && ((ch = id.charAt(pos - 2)) < '0' || ch > '9')) {
            String className = ourClass.name();
            if (className.startsWith(Names.JAVA_LANG_REF_0)
                    || className.startsWith(Names.JAVA_LANG_REFLECT_0)
                    || ((pos = className.lastIndexOf('.')) > 0
                            && className.length() - pos > 2
                            && className.charAt(pos + 1) == 'V' && className
                            .charAt(pos + 2) == 'M'))
                return true;
        }
        return false;
    }

    boolean writeMethodCall(OutputContext oc, ClassDefinition receiverClass,
            String receiverString, int isNotNull, boolean hasStackObjRet,
            ExpressionType origResType) {
        Term.assertCond(receiverString != null);
        boolean rightParenNeeded = false;
        if (origResType != resType) {
            oc.cPrint("(");
            oc.cPrint(origResType.castName());
            oc.cPrint(")");
        }
        if (used
                && (receiverClass == null || receiverClass.hasRealInstances())
                && (isAbstract() || (receiverClass != null && allowOverride() && receiverClass
                        .subclassHasMethod(
                                methodSignature().signatureString(),
                                isProtectedOrPublic() ? null : ourClass
                                        .getPackageName())))) {
            Term.assertCond(!hasStackObjRet);
            if (!isVirtual) {
                isVirtual = true;
                ourClass.setVirtualInSubclasses(methodSignature()
                        .signatureString());
            }
            oc.cPrint(isNotNull > 0 ? "JCGO_CALL_NZVFUNC"
                    : isNotNull != 0 ? "JCGO_CALL_EVFUNC" : "JCGO_CALL_VFUNC");
            oc.cPrint("(");
            oc.cPrint(receiverString);
            oc.cPrint(")->");
            oc.cPrint(csign());
            Main.dict.indirectCalls++;
        } else {
            if (isNotNull <= 0) {
                if (origResType != resType) {
                    oc.cPrint("(");
                    rightParenNeeded = true;
                }
                oc.cPrint(isNotNull != 0 ? "JCGO_CALL_EFINALF"
                        : "JCGO_CALL_FINALF");
                oc.cPrint("(");
                oc.cPrint(receiverString);
                oc.cPrint(") ");
            }
            if (usedExact
                    && (receiverClass == null || receiverClass
                            .hasRealInstances())) {
                oc.cPrint(hasStackObjRet ? stackObjRetRoutineCName()
                        : routineCName());
                Main.dict.normalCalls++;
            } else {
                oc.cPrint("(");
                oc.cPrint(resType.castName());
                oc.cPrint(")");
                oc.cPrint(resType.objectSize() >= Type.CLASSINTERFACE ? LexTerm.NULL_STR
                        : "0");
            }
        }
        return rightParenNeeded;
    }

    void produceOutput(OutputContext oc) {
        Term.assertCond(analysisDone && leaksDiscoverDone);
        if (outputDone)
            return;
        outputDone = true;
        if (isAbstract())
            return;
        Main.dict.methodsWritten++;
        Main.dict.message("Writing method: " + ourClass.name() + "."
                + methodSignature().getInfo());
        if (!stackObjRetRequired) {
            stackObjRetTerm = null;
        }
        boolean alreadyReferenced = referenced;
        String parms = OutputContext.paramStringOutputNoComma(paramList, false);
        boolean hasParams = true;
        if (parms.length() == 0) {
            hasParams = false;
            parms = Type.cName[Type.VOID];
        }
        String jniName = null;
        if (isNative() && !Names.isVMCoreClass(ourClass.name())) {
            jniName = methodSignature().getJniNameNoPrefix(ourClass);
            oc.hPrint("#ifndef NOJAVA_");
            oc.hPrint(jniName);
            oc.hPrint("\n");
            oc.hPrint("JNIIMPORT ");
            oc.hPrint(resType.getJniName());
            oc.hPrint(" JNICALL JCGO_JNI_FUNC(Java_");
            oc.hPrint(jniName);
            oc.hPrint(")( JNIEnv *pJniEnv, ");
            oc.hPrint((isClassMethod() ? Main.dict.get(Names.JAVA_LANG_CLASS)
                    : ourClass).getJniName());
            oc.hPrint(" ");
            oc.hPrint(This.CNAME);
            OutputContext oc2 = new OutputContext();
            paramList.parameterOutput(oc2, false, Type.VOID);
            oc.hPrint(oc2.instanceToString());
            oc.hPrint(" );");
            oc.hPrint("#endif\n");
        }
        StringBuffer sb = new StringBuffer();
        if (!isClassMethod()
                || ourClass != Main.dict.mainClass
                || (modifiers & (AccModifier.PRIVATE | AccModifier.PROTECTED | AccModifier.NATIVE)) != 0)
            sb.append(stackObjRetRequired || allowInline() ? (alreadyReferenced ? "JCGO_NOSEP_FRWINL "
                    : "JCGO_NOSEP_INLINE ")
                    : "JCGO_NOSEP_STATIC ");
        sb.append(resType.castName());
        sb.append(" CFASTCALL\n");
        sb.append(routineCName());
        sb.append("( ");
        if (isClassMethod()) {
            sb.append(parms);
        } else {
            sb.append(ourClass.castName());
            sb.append(' ');
            sb.append(This.CNAME);
            if (hasParams) {
                sb.append(", ");
                sb.append(parms);
            }
        }
        sb.append(" )");
        if (isNative() && ourClass.name().equals(Names.JAVA_LANG_VMMATH)) {
            oc.hPrint("#define JCGO_NATMATH_");
            oc.hPrint(csign());
            oc.hPrint("\n");
        }
        oc.hPrint(sb.toString());
        oc.hPrint(";");
        if (jniName != null || !isNative()) {
            String stackObjRetCode = null;
            if (stackObjRetRequired) {
                oc.cAndHPrint(allowInline() ? (alreadyReferenced ? "JCGO_NOSEP_FRWINL "
                        : "JCGO_NOSEP_INLINE ")
                        : "JCGO_NOSEP_STATIC ");
                oc.cAndHPrint(resType.castName());
                oc.cAndHPrint(" CFASTCALL\n");
                oc.cAndHPrint(stackObjRetRoutineCName());
                oc.cAndHPrint("( ");
                if (!isClassMethod()) {
                    oc.cAndHPrint(ourClass.castName());
                    oc.cAndHPrint(" ");
                    oc.cAndHPrint(This.CNAME);
                    oc.cAndHPrint(", ");
                }
                if (hasParams) {
                    oc.cAndHPrint(parms);
                    oc.cAndHPrint(", ");
                }
                OutputContext oc2 = new OutputContext();
                oc.cAndHPrint(writeStackObjRetCode(oc2).castName());
                stackObjRetCode = oc2.instanceToString();
                oc.cAndHPrint(" ");
                oc.cAndHPrint(STACKOBJ_RETNAME);
                oc.cAndHPrint(" )");
                oc.hPrint(";");
            } else {
                oc.cPrint(sb.toString());
            }
            oc.cPrint("{");
            if (jniName != null) {
                oc.cPrint("\n#ifdef NOJAVA_");
                oc.cPrint(jniName);
                oc.cPrint("\010");
                oc.cPrint("jcgo_jniNoNativeFunc();");
                if (resType.objectSize() != Type.VOID) {
                    oc.cPrint("return ");
                    oc.cPrint(resType.objectSize() < Type.CLASSINTERFACE ? "("
                            + resType.castName() + ")0" : LexTerm.NULL_STR);
                    oc.cPrint(";");
                }
                oc.cPrint("\n#else\010");
                String targetStr = This.CNAME;
                boolean hasRetVal = false;
                if (resType.objectSize() < Type.VOID
                        || (isSynchronized() && resType.objectSize() > Type.VOID)) {
                    oc.cPrint(resType.castName());
                    oc.cPrint(" jcgo_retval;");
                    hasRetVal = true;
                }
                boolean needsBrace = false;
                if (isClassMethod()) {
                    targetStr = ourClass.getClassRefStr(false);
                    if (needsTrigClinit && ourClass.writeTrigClinit(oc)) {
                        oc.cPrint("{");
                        needsBrace = true;
                    }
                }
                if (isSynchronized()) {
                    oc.cPrint("JCGO_SYNC_BLOCKSAFENZ(");
                    oc.cPrint(targetStr);
                    oc.cPrint("){");
                }
                int objArgsCnt = 0;
                Enumeration en = methodSignature().elements();
                while (en.hasMoreElements()) {
                    if (((ExpressionType) en.nextElement()).objectSize() > Type.VOID) {
                        objArgsCnt++;
                    }
                }
                oc.cPrint("JCGO_JNI_BLOCK(");
                oc.cPrint(Integer.toString(objArgsCnt));
                oc.cPrint(")\010");
                if (resType.objectSize() != Type.VOID) {
                    oc.cPrint(hasRetVal ? "jcgo_retval= " : "return ");
                    if (resType.objectSize() > Type.VOID) {
                        oc.cPrint("(");
                        oc.cPrint(resType.castName());
                        oc.cPrint(")jcgo_jniLeave(jcgo_pJniEnv, ");
                        if (!resType.getJniName().equals(
                                Type.jniName[Type.CLASSINTERFACE])) {
                            oc.cPrint("(");
                            oc.cPrint(Type.jniName[Type.CLASSINTERFACE]);
                            oc.cPrint(")");
                        }
                    }
                }
                oc.cPrint("JCGO_JNI_FUNC(Java_");
                oc.cPrint(jniName);
                oc.cPrint(")(jcgo_pJniEnv, ");
                Term.assertCond(oc.arrInitCount == -1);
                VariableDefinition.outputJniParam(oc,
                        isClassMethod() ? Main.dict.get(Names.JAVA_LANG_CLASS)
                                : ourClass, targetStr);
                paramList.parameterOutput(oc, true, Type.VOID);
                oc.arrInitCount = -1;
                oc.cPrint(")");
                if (resType.objectSize() <= Type.VOID) {
                    oc.cPrint(";");
                    oc.cPrint("jcgo_jniLeave(jcgo_pJniEnv, NULL");
                }
                oc.cPrint(");");
                if (isSynchronized()) {
                    oc.cPrint("}");
                    oc.cPrint("JCGO_SYNC_END\010");
                }
                if (needsBrace) {
                    oc.cPrint("}");
                }
                if (hasRetVal) {
                    oc.cPrint("return jcgo_retval;");
                }
                oc.cPrint("\n#endif\010");
            } else if (ourClass.isProxyClass() && !isConstructor()) {
                produceProxyMethodBody(oc);
            } else {
                if (ourClass.hasRealInstances() || isClassMethod()) {
                    boolean needsBrace = false;
                    if (isClassMethod()
                            && (needsTrigClinit || isVMSpecialMethod())) {
                        needsBrace = ourClass.writeTrigClinit(oc);
                    }
                    Enumeration en = getLocalsNames();
                    while (en.hasMoreElements()) {
                        if (getLocalVar((String) en.nextElement())
                                .outputParamNoClobber(oc)) {
                            needsBrace = true;
                        }
                    }
                    if (isSynchronized()) {
                        if (needsBrace) {
                            oc.cPrint("{");
                        }
                        oc.cPrint("JCGO_SYNC_BLOCKSAFENZ(");
                        oc.cPrint(isClassMethod() ? ourClass
                                .getClassRefStr(false) : This.CNAME);
                        oc.cPrint(")\010");
                    } else {
                        needsBrace = false;
                    }
                    oc.stackObjCountReset();
                    body.processOutput(oc);
                    if (needsBrace) {
                        oc.cPrint("}");
                    }
                    if (needsDummyRet && body.isReturnAtEnd(false)) {
                        needsDummyRet = false;
                    }
                } else {
                    needsDummyRet = true;
                }
                if (needsDummyRet && resType.objectSize() != Type.VOID) {
                    oc.cPrint("return ");
                    oc.cPrint(isConstructor() ? "This"
                            : resType.objectSize() < Type.CLASSINTERFACE ? "("
                                    + resType.castName() + ")0"
                                    : LexTerm.NULL_STR);
                    oc.cPrint(";");
                }
            }
            oc.cPrint("}\n\n");
            if (stackObjRetRequired) {
                Term.assertCond(jniName == null);
                oc.cPrint(sb.toString());
                oc.cPrint("{");
                writeStackObjTrigClinit(oc);
                oc.cPrint("return ");
                oc.cPrint(stackObjRetRoutineCName());
                oc.cPrint("(");
                if (isClassMethod()) {
                    oc.cPrint("\010 ");
                } else {
                    oc.cPrint(This.CNAME);
                    oc.cPrint(", ");
                }
                if (hasParams) {
                    oc.cPrint(OutputContext.paramStringOutputNoComma(paramList,
                            true));
                    oc.cPrint(", ");
                }
                oc.cPrint(stackObjRetCode);
                oc.cPrint(");}\n\n");
            }
        }
        if (isConstructor() && isNewUsed) {
            Term.assertCond(!ourClass.isAbstractOrInterface());
            oc.cAndHPrint(newReferenced ? "JCGO_NOSEP_FRWINL "
                    : "JCGO_NOSEP_INLINE ");
            oc.cAndHPrint(resType.castName());
            oc.cAndHPrint(" CFASTCALL\n");
            oc.cAndHPrint(newRoutineCName());
            oc.cAndHPrint("( ");
            oc.cAndHPrint(parms);
            oc.cAndHPrint(" )");
            oc.hPrint(";");
            oc.cPrint("{");
            if (needsTrigClinit) {
                ourClass.writeTrigClinit(oc);
            }
            oc.cPrint("return ");
            oc.cPrint(routineCName());
            oc.cPrint("(\010 ");
            oc.cPrint(ourClass.cNewObjectCode());
            oc.parameterOutputAsArg(paramList);
            oc.cPrint(");}\n\n");
        }
        oc.hPrint("\n\n");
    }

    private void produceProxyMethodBody(OutputContext oc) {
        MethodDefinition md = Main.dict.get(Names.JAVA_LANG_REFLECT_VMPROXY)
                .getMethod(Names.SIGN_INVOKEPROXYHANDLER0X);
        if (md == null || !md.usedExact() || !md.isClassMethod()) {
            if (resType.objectSize() != Type.VOID) {
                oc.cPrint("return ");
                oc.cPrint(resType.objectSize() < Type.CLASSINTERFACE ? "("
                        + resType.castName() + ")0" : LexTerm.NULL_STR);
                oc.cPrint(";");
            }
            return;
        }
        int[] indices = new int[Type.VOID - Type.INT + 1];
        MethodSignature msig = methodSignature();
        Enumeration en = msig.elements();
        while (en.hasMoreElements()) {
            int s0 = ((ExpressionType) en.nextElement()).objectSize();
            indices[s0 <= Type.INT ? 0 : s0 < Type.VOID ? s0 - Type.INT
                    : Type.VOID - Type.INT]++;
        }
        if (resType.objectSize() < Type.VOID) {
            int s1 = resType.objectSize();
            if (s1 <= Type.INT) {
                s1 = Type.INT;
            }
            if (indices[s1 - Type.INT] == 0) {
                indices[s1 - Type.INT] = 1;
            }
        }
        for (int s1 = Type.INT; s1 <= Type.VOID; s1++) {
            if (indices[s1 - Type.INT] > 0) {
                oc.cPrint(Main.dict.addArrayTypeDefn(s1,
                        indices[s1 - Type.INT], ourClass, null));
                oc.cPrint(" jcgo_");
                oc.cPrint(s1 != Type.VOID ? Type.name[s1] : "object");
                oc.cPrint("Args;");
            }
        }
        for (int s1 = Type.INT; s1 <= Type.VOID; s1++) {
            if (indices[s1 - Type.INT] > 0) {
                oc.cPrint("(");
                oc.cPrint(Type.cName[Type.VOID]);
                oc.cPrint(")");
                oc.cPrint(s1 != Type.VOID ? "JCGO_STACKOBJ_PRIMARRNEW"
                        : "JCGO_STACKOBJ_OBJARRNEW");
                oc.cPrint("(jcgo_");
                oc.cPrint(s1 != Type.VOID ? Type.name[s1] : "object");
                oc.cPrint("Args, ");
                oc.cPrint(ClassDefinition.arrayVTableCName(s1, 0));
                oc.cPrint(", ");
                if (s1 == Type.VOID) {
                    oc.cPrint(Main.dict.get(Names.JAVA_LANG_OBJECT)
                            .getClassRefStr(false));
                    oc.cPrint(", ");
                }
                oc.cPrint(Integer.toString(indices[s1 - Type.INT]));
                oc.cPrint(");");
                indices[s1 - Type.INT] = 0;
            }
        }
        Enumeration en2 = msig.elements();
        for (int index = 0; en2.hasMoreElements(); index++) {
            int s0 = ((ExpressionType) en2.nextElement()).objectSize();
            int s1 = s0 <= Type.INT ? Type.INT : s0 < Type.VOID ? s0
                    : Type.VOID;
            oc.cPrint("JCGO_ARR_INTERNALACC(");
            oc.cPrint(Type.cName[s1 != Type.VOID ? s1 : Type.CLASSINTERFACE]);
            oc.cPrint(", (");
            oc.cPrint(Type.cName[s1 + Type.CLASSINTERFACE]);
            oc.cPrint(")JCGO_OBJREF_OF(jcgo_");
            oc.cPrint(s1 != Type.VOID ? Type.name[s1] : "object");
            oc.cPrint("Args), ");
            oc.cPrint(Integer.toString(indices[s1 - Type.INT]++));
            oc.cPrint(")= ");
            if (s0 >= Type.CLASSINTERFACE) {
                oc.cPrint("(");
                oc.cPrint(Type.cName[Type.CLASSINTERFACE]);
                oc.cPrint(")");
            } else if (s0 < Type.INT && s0 > Type.BOOLEAN) {
                oc.cPrint("(");
                oc.cPrint(Type.cName[Type.INT]);
                oc.cPrint(")");
            }
            Term t = paramList.getArgumentTerm(index);
            Term.assertCond(t != null);
            OutputContext oc2 = new OutputContext();
            t.parameterOutput(oc2, true, s0 < Type.CLASSINTERFACE ? s0
                    : Type.NULLREF);
            oc.cPrint(oc2.instanceToString().substring(2));
            if (s0 == Type.BOOLEAN) {
                oc.cPrint("? 1\003 :\003 0");
            }
            oc.cPrint(";");
        }
        if (resType.objectSize() >= Type.CLASSINTERFACE) {
            oc.cPrint("return ");
            if (md.exprType() != resType) {
                oc.cPrint("(");
                oc.cPrint(resType.castName());
                oc.cPrint(")");
            }
        }
        oc.cPrint(md.routineCName());
        oc.cPrint("((");
        oc.cPrint(Main.dict.get(Names.JAVA_LANG_OBJECT).castName());
        oc.cPrint(")");
        oc.cPrint(This.CNAME);
        oc.cPrint(", ");
        String sigString = methodSignature().signatureString();
        md = ourClass.getOverridenMethod(sigString, resType);
        Term.assertCond(md != null && md.used);
        ClassDefinition cd = md.definingClass();
        oc.cPrint(cd.getClassRefStr(false));
        int s0 = resType.objectSize();
        for (int s1 = Type.INT; s1 <= Type.VOID; s1++) {
            oc.cPrint(", ");
            if (indices[s1 - Type.INT] > 0
                    || (s0 < Type.VOID && (s0 > Type.INT ? s0 : Type.INT) == s1)) {
                oc.cPrint("(");
                oc.cPrint(Type.cName[s1 + Type.CLASSINTERFACE]);
                oc.cPrint(")JCGO_OBJREF_OF(jcgo_");
                oc.cPrint(s1 != Type.VOID ? Type.name[s1] : "object");
                oc.cPrint("Args)");
            } else {
                oc.cPrint(LexTerm.NULL_STR);
            }
        }
        oc.cPrint(", ");
        oc.cPrint(Integer.toString(cd.getReflectedMethodSlot(sigString)));
        oc.cPrint(", ");
        oc.cPrint(Integer.toString(ourClass.getReflectedMethodSlot(sigString)));
        oc.cPrint(");");
        if (s0 < Type.VOID) {
            oc.cPrint("return ");
            boolean isBool = false;
            if (s0 < Type.INT) {
                oc.cPrint("(");
                oc.cPrint(Type.cName[s0]);
                oc.cPrint(")");
                if (s0 == Type.BOOLEAN) {
                    oc.cPrint("(");
                    isBool = true;
                }
                s0 = Type.INT;
            }
            oc.cPrint("JCGO_ARR_INTERNALACC(");
            oc.cPrint(Type.cName[s0]);
            oc.cPrint(", (");
            oc.cPrint(Type.cName[s0 + Type.CLASSINTERFACE]);
            oc.cPrint(")JCGO_OBJREF_OF(jcgo_");
            oc.cPrint(Type.name[s0]);
            oc.cPrint("Args), 0)");
            if (isBool) {
                oc.cPrint("!= 0)");
            }
            oc.cPrint(";");
        }
    }

    boolean isVirtualUsed() {
        return isVirtual;
    }

    void produceJumpTableEntry(ClassDefinition currentClass, boolean isDuplicate) {
        Term.assertCond(used);
        OutputContext oc = currentClass.outputContext();
        String parms = OutputContext.paramStringOutputNoComma(paramList, false);
        oc.hPrint(resType.castName());
        oc.hPrint(" (CFASTCALL *");
        oc.hPrint(isDuplicate ? currentClass.nextDummyEntryName() : csign());
        oc.hPrint(")( ");
        oc.hPrint(ourClass.castName());
        oc.hPrint(" ");
        oc.hPrint(This.CNAME);
        if (parms.length() > 0) {
            oc.hPrint(", ");
            oc.hPrint(parms);
        }
        oc.hPrint(" );");
        if (!currentClass.isNotInstantated()) {
            oc.cPrint(",\010");
            if (isAbstract() || !usedExact) {
                oc.cPrint("0");
            } else {
                MethodDefinition md = this;
                if (!hasParameters()) {
                    md = replaceMethodEntry();
                    if (resType.objectSize() == Type.VOID && !md.isNative()
                            && !md.hasNonEmptyBody()) {
                        md = Main.dict.get(Names.JAVA_LANG_OBJECT).getMethod(
                                Names.SIGN_FINALIZE);
                        if (md == null || !md.usedExact()
                                || resType != md.resType || md.isClassMethod()) {
                            md = this;
                        }
                    }
                    if (md.definingClass() != ourClass) {
                        oc.cPrint("(");
                        oc.cPrint(resType.castName());
                        oc.cPrint(" (CFASTCALL*)(");
                        oc.cPrint(ourClass.castName());
                        oc.cPrint("))");
                    }
                }
                oc.cPrint(md.routineCName());
            }
        }
    }

    void setTraceExprType(ExpressionType curType) {
        if (resType.objectSize() >= Type.CLASSINTERFACE) {
            if (!curType.hasRealInstances()) {
                curType = Main.dict.classTable[Type.NULLREF];
            }
            curTraceType = curTraceType != null ? ClassDefinition
                    .maxCommonExprOf(curTraceType, curType, null) : curType;
        }
    }

    ExpressionType traceBody(ObjVector parmTraceSig) {
        Term.assertCond(usedExact);
        if (!isConstructor() && !isClassMethod() && ourClass.isProxyClass()) {
            MethodDefinition md = Main.dict
                    .get(Names.JAVA_LANG_REFLECT_VMPROXY).getMethod(
                            Names.SIGN_INVOKEPROXYHANDLER0X);
            if (md != null) {
                md.methodTraceClassInit(false, null, null);
            }
            return null;
        }
        if (helperMethod != null) {
            Main.dict.curHelperForMethod = this;
            helperMethod.body.traceClassInit();
            Main.dict.curHelperForMethod = null;
        }
        if (isNative()) {
            if (!Names.isVMCoreClass(ourClass.name())) {
                ourClass.classTraceClassInit(false);
                ClassDefinition cd = Main.dict.get(Names.JAVA_LANG_VMCLASS);
                MethodDefinition md;
                if (cd.used()
                        && (md = cd.getMethod(Names.SIGN_ARRAYCLASSOF0X)) != null
                        && md.isClassMethod()) {
                    md.methodTraceClassInit(true, null, null);
                }
            }
            ClassDefinition cd = resType.signatureClass();
            if (cd.objectSize() == Type.CLASSINTERFACE && cd.used()) {
                if (!cd.constructorTraceClassInit(false)) {
                    cd.instanceCreatedOnTrace();
                }
                if (cd.superClass() != null) {
                    cd.constructorTraceClassInitInSubclasses();
                }
            }
            return null;
        }
        if (hasParameters()) {
            paramList.setTraceExprType(parmTraceSig != null ? parmTraceSig
                    .elements() : null);
        }
        ExpressionType oldCurTraceType = curTraceType;
        curTraceType = null;
        body.traceClassInit();
        ExpressionType curType = null;
        if (actualType != null && (curType = curTraceType) != null) {
            if (!actualType.hasRealInstances()) {
                curType = Main.dict.classTable[Type.NULLREF];
            } else if (!ClassDefinition.isAssignableFrom(actualType, curType,
                    null) || actualType == curType) {
                curType = null;
            }
        }
        curTraceType = oldCurTraceType;
        return curType;
    }

    ExpressionType methodTraceClassInit(boolean isWeak,
            ExpressionType curActualClass, ObjVector parmTraceSig) {
        ExpressionType curType = null;
        if (usedExact) {
            if (isWeak && !Main.dict.classInitWeakDepend) {
                Main.dict.classInitWeakDepend = true;
                curType = methodTraceClassInit(false, curActualClass,
                        parmTraceSig);
                Main.dict.classInitWeakDepend = false;
                return curType;
            }
            if (isClassMethod()) {
                curActualClass = null;
            } else {
                Term.assertCond(curActualClass == null
                        || ourClass.isAssignableFrom(
                                curActualClass.receiverClass(), 0, null));
                if (!ourClass.hasRealInstances() && !isConstructor())
                    return resType.objectSize() >= Type.CLASSINTERFACE ? Main.dict.classTable[Type.NULLREF]
                            : null;
            }
            MethodTraceInfo traceInfo = MethodTraceInfo.create(this,
                    curActualClass, isNative() ? null : parmTraceSig);
            Main.dict.curTraceInfo.addMethodCall(traceInfo);
            if (traceInfo.isNotTraced() && !isConstructor()) {
                ExpressionType actual = actualExprType();
                int s0;
                if (((s0 = actual.objectSize()) == Type.CLASSINTERFACE || s0 == Type.OBJECTARRAY)
                        && actual.signatureClass().hasInstantatedSubclasses(
                                false)) {
                    traceInfo.traceMethod();
                }
            }
            curType = traceInfo.getResTraceType();
        }
        ClassDefinition aclass;
        if (used
                && curActualClass != null
                && isVirtual
                && allowOverride()
                && (aclass = curActualClass.receiverClass()) == curActualClass
                && aclass.superClass() != null
                && (!aclass.name().equals(Names.JAVA_LANG_THROWABLE) || !resType
                        .name().equals(Names.JAVA_LANG_STRING))) {
            ExpressionType curType2 = aclass.traceClInitInSubclasses(
                    methodSignature().signatureString(),
                    isProtectedOrPublic() ? null : ourClass.getPackageName(),
                    !isAbstract(), parmTraceSig);
            if (curType != null) {
                curType = isAbstract() ? curType2 : ClassDefinition
                        .maxCommonExprOf(curType, curType2, null);
                if (actualType != null
                        && !ClassDefinition.isAssignableFrom(actualType,
                                curType, null)) {
                    curType = actualType;
                }
            } else if (!usedExact) {
                curType = curType2;
            }
        }
        if (usedExact
                && ourClass.name().equals(Names.JAVA_LANG_THREAD)
                && methodSignature().signatureString().equals(
                        Names.SIGN_INIT_THREADGROUP_2)) {
            MethodDefinition md = null;
            if ((curActualClass != null
                    && (md = curActualClass.receiverClass().getMethod(
                            Names.SIGN_RUN)) != null && md.definingClass() != ourClass)
                    || (parmTraceSig == null && (md != null || (md = ourClass
                            .getMethod(Names.SIGN_RUN)) != null))) {
                md.methodTraceClassInit(false, curActualClass, null);
            } else {
                ExpressionType curType2;
                if (parmTraceSig != null
                        && parmTraceSig.size() > 1
                        && (curType2 = (ExpressionType) parmTraceSig
                                .elementAt(1)).objectSize() != Type.NULLREF) {
                    aclass = Main.dict.get(Names.JAVA_LANG_RUNNABLE);
                    if (aclass.used()
                            && aclass.isAssignableFrom(
                                    curType2.receiverClass(), 0, null)
                            && (md = curType2.receiverClass().getMethod(
                                    Names.SIGN_RUN)) != null) {
                        md.methodTraceClassInit(false, curType2, null);
                    } else if ((md = ourClass.getMethod(Names.SIGN_RUN)) != null) {
                        md.methodTraceClassInit(false, curActualClass, null);
                    }
                }
            }
        }
        return curType;
    }
}