Java VM.isInternal方法代码示例

import com.sun.squawk.VM; //导入方法依赖的package包/类
/**
     * Given the classes's access and the suite type,
     * determine the final accessibility of the class outside of this suite.
     *
     * @param klass the klass
     * @return true if an external suite could possibly access this klass.
     */
    public boolean isExternallyVisible(Klass klass) {
        int modifiers = klass.getModifiers();
        int suiteType = translator.getSuiteType();

        if (VM.isDynamic(klass)) {
            // if "dynamic", then class may be loaded by Class.findClass(), so we have to assume that it is used.
            Assert.always(!VM.isInternal(klass));
            return true;
        } else if (VM.isInternal(klass)) {
            // if the symbol wasn't marked as "export" or "dynamic" in the library.proprties file,
            // then there is no way that this is externally visible.
            return false;
        } else {
            // It's declared externally visible, but is it really?
            Assert.that(Modifier.isPackagePrivate(modifiers) || Modifier.isProtected(modifiers) || Modifier.isPublic(modifiers));

            switch (suiteType) {
                case Suite.APPLICATION:
                    return false;
                case Suite.LIBRARY:
                    // what can we do here
                    if (Modifier.isPackagePrivate(modifiers)) {
                        // treat as internal:
/*if[ENABLE_VERBOSE]*/
                        if (VM.isVerbose()) {
                            System.out.println("### FYI - Found package-private class: " + klass);
                        }
/*end[ENABLE_VERBOSE]*/			
                        return false;
                    }
                    return true;
                default:
                    // extendable and debuggable suites leave all symbols externally visible.
                    return true;
            }
        }
    }
 

import com.sun.squawk.VM; //导入方法依赖的package包/类
/**
 * Given the method's access, the defining class' access, and the suite type,
 * determine the final accessibility of the method outside of this suite.
 * 
 * Note that we are talking about the accessibility of a particular method, 
 * not all of the methods that override a super method. There are cases where
 * a super method is not accessible, but an override is. A latter check for overriding
 * will mark the super method as used.
 * 
 * @param mw the MMethodDB.Entry
 * @return true if an external suite could possibly access this method.
 */
public boolean isExternallyVisible(MethodDB.Entry mw) {
    Method m = mw.m;
    int modifiers = m.getModifiers();
    int suiteType = translator.getSuiteType();
    boolean sealedPackages = (suiteType == Suite.LIBRARY) || (suiteType == Suite.APPLICATION);

    if (Modifier.isPrivate(modifiers)) {
        return false;
    } else if (translator.getSuite().isBootstrap() && VM.isInternal(m)) {
        // if the symbol is stripped, and it wasn't marked as "CrossSuitePrivate" in the library.proprties file,
        // then there is no way that this is externally visible.
        return false;
    } else {
        // It's declared externally visible, but is it really?
        Assert.that(Modifier.isPackagePrivate(modifiers) || Modifier.isProtected(modifiers) || Modifier.isPublic(modifiers));
        
        // Check visibility upwards through parent suites:
        if (!m.isStatic()) {
            // This could be an override of a method in another suite.
            // If so, it might be called and we can't tell, so return true
            if (isSuperMethodDefinedOustideOfSuite(mw)) {
                return true;
            }
        }
        
        // Check visibility downwards through child suites. Look for cases where a child suite
        // could call this protected or public method. Or conversley,
        // cases when there is no way a child suite could call this method.
        switch (suiteType) {
            case Suite.APPLICATION:
                // no possible child suite:
                return false;
                
            case Suite.LIBRARY: {
                // The complicated case:
                
                // check the methods's modifier
                if (Modifier.isPackagePrivate(modifiers)) {
                    // child suites can't call this package-private method
                    return false;
                } else if (Modifier.isProtected(modifiers)) {
                     if (m.getDefiningClass().isFinal() // there can be no subclass, so has same effect as package-private:
                         || !m.getDefiningClass().isPublic()) { // there can be no external subclass, so has same effect as package-private:
                        return false;
                    }
                    return true;
                } else /* Modifier.isPublic(modifiers) */ {
                    Assert.that(Modifier.isPublic(modifiers));
                    if (!m.getDefiningClass().isPublic()) {
                        return false;
                    }
                    return true;
                }
            }
            
            default:
                // extendable and debuggable suites leave all symbols externally visible.
                return true;
        }
    }
}