118             if ((allowedModes & PROTECTED) == 0)
 119                 return false;
 120             // Protected members are accessible by subclasses, which does not include interfaces.
 121             // Interfaces are types, not classes. They should not have access to
 122             // protected members in j.l.Object, even though it is their superclass.
 123             if ((mods & STATIC) != 0 &&
 124                 !isRelatedClass(refc, lookupClass))
 125                 return false;
 126             if ((allowedModes & PROTECTED) != 0 &&
 127                 isSubClass(lookupClass, defc))
 128                 return true;
 129             return false;
 130         case PACKAGE_ONLY:  // That is, zero.  Unmarked member is package-only access.
 131             assert !defc.isInterface(); // package-private members aren't allowed in interfaces
 132             return ((allowedModes & PACKAGE_ALLOWED) != 0 &&
 133                     isSamePackage(defc, lookupClass));
 134         case PRIVATE:
 135             // Rules for privates follows access rules for nestmates.
 136             boolean canAccess = ((allowedModes & PRIVATE) != 0 &&
 137                                  Reflection.areNestMates(defc, lookupClass));
 138             // FIX ME: Sanity check refc == defc. Either remove or convert to
 139             // plain assert before integration.
 140             myassert((canAccess && refc == defc) || !canAccess);
 141             return canAccess;
 142         default:
 143             throw new IllegalArgumentException("bad modifiers: "+Modifier.toString(mods));
 144         }
 145     }
 146     static void myassert(boolean cond) {
 147         if (!cond) throw new Error("Assertion failed");
 148     }
 149 
 150     static boolean isRelatedClass(Class<?> refc, Class<?> lookupClass) {
 151         return (refc == lookupClass ||
 152                 isSubClass(refc, lookupClass) ||
 153                 isSubClass(lookupClass, refc));
 154     }
 155 
 156     static boolean isSubClass(Class<?> lookupClass, Class<?> defc) {
 157         return defc.isAssignableFrom(lookupClass) &&
 158                !lookupClass.isInterface(); // interfaces are types, not classes.
 159     }
 160 
 161     static int getClassModifiers(Class<?> c) {
 162         // This would return the mask stored by javac for the source-level modifiers.
 163         //   return c.getModifiers();
 164         // But what we need for JVM access checks are the actual bits from the class header.
 165         // ...But arrays and primitives are synthesized with their own odd flags:
 166         if (c.isArray() || c.isPrimitive())
 167             return c.getModifiers();

 118             if ((allowedModes & PROTECTED) == 0)
 119                 return false;
 120             // Protected members are accessible by subclasses, which does not include interfaces.
 121             // Interfaces are types, not classes. They should not have access to
 122             // protected members in j.l.Object, even though it is their superclass.
 123             if ((mods & STATIC) != 0 &&
 124                 !isRelatedClass(refc, lookupClass))
 125                 return false;
 126             if ((allowedModes & PROTECTED) != 0 &&
 127                 isSubClass(lookupClass, defc))
 128                 return true;
 129             return false;
 130         case PACKAGE_ONLY:  // That is, zero.  Unmarked member is package-only access.
 131             assert !defc.isInterface(); // package-private members aren't allowed in interfaces
 132             return ((allowedModes & PACKAGE_ALLOWED) != 0 &&
 133                     isSamePackage(defc, lookupClass));
 134         case PRIVATE:
 135             // Rules for privates follows access rules for nestmates.
 136             boolean canAccess = ((allowedModes & PRIVATE) != 0 &&
 137                                  Reflection.areNestMates(defc, lookupClass));
 138             // for private methods the selected method equals the
 139             // resolved method - so refc == defc
 140             assert (canAccess && refc == defc) || !canAccess;
 141             return canAccess;
 142         default:
 143             throw new IllegalArgumentException("bad modifiers: "+Modifier.toString(mods));
 144         }



 145     }
 146 
 147     static boolean isRelatedClass(Class<?> refc, Class<?> lookupClass) {
 148         return (refc == lookupClass ||
 149                 isSubClass(refc, lookupClass) ||
 150                 isSubClass(lookupClass, refc));
 151     }
 152 
 153     static boolean isSubClass(Class<?> lookupClass, Class<?> defc) {
 154         return defc.isAssignableFrom(lookupClass) &&
 155                !lookupClass.isInterface(); // interfaces are types, not classes.
 156     }
 157 
 158     static int getClassModifiers(Class<?> c) {
 159         // This would return the mask stored by javac for the source-level modifiers.
 160         //   return c.getModifiers();
 161         // But what we need for JVM access checks are the actual bits from the class header.
 162         // ...But arrays and primitives are synthesized with their own odd flags:
 163         if (c.isArray() || c.isPrimitive())
 164             return c.getModifiers();