< prev index next >

src/jdk.compiler/share/classes/com/sun/tools/javac/code/Flags.java

Print this page




  81     public static final int VOLATILE     = 1<<6;
  82     public static final int TRANSIENT    = 1<<7;
  83     public static final int NATIVE       = 1<<8;
  84     public static final int INTERFACE    = 1<<9;
  85     public static final int ABSTRACT     = 1<<10;
  86     public static final int STRICTFP     = 1<<11;
  87 
  88     /* Flag that marks a symbol synthetic, added in classfile v49.0. */
  89     public static final int SYNTHETIC    = 1<<12;
  90 
  91     /** Flag that marks attribute interfaces, added in classfile v49.0. */
  92     public static final int ANNOTATION   = 1<<13;
  93 
  94     /** An enumeration type or an enumeration constant, added in
  95      *  classfile v49.0. */
  96     public static final int ENUM         = 1<<14;
  97 
  98     /** Added in SE8, represents constructs implicitly declared in source. */
  99     public static final int MANDATED     = 1<<15;
 100 



 101     public static final int StandardFlags = 0x0fff;
 102 
 103     // Because the following access flags are overloaded with other
 104     // bit positions, we translate them when reading and writing class
 105     // files into unique bits positions: ACC_SYNTHETIC <-> SYNTHETIC,
 106     // for example.
 107     public static final int ACC_SUPER    = 0x0020;
 108     public static final int ACC_BRIDGE   = 0x0040;
 109     public static final int ACC_VARARGS  = 0x0080;

 110     public static final int ACC_MODULE   = 0x8000;
 111 
 112     /*****************************************
 113      * Internal compiler flags (no bits in the lower 16).
 114      *****************************************/
 115 
 116     /** Flag is set if symbol is deprecated.  See also DEPRECATED_REMOVAL.
 117      */
 118     public static final int DEPRECATED   = 1<<17;
 119 
 120     /** Flag is set for a variable symbol if the variable's definition
 121      *  has an initializer part.
 122      */
 123     public static final int HASINIT          = 1<<18;
 124 




 125     /** Flag is set for compiler-generated anonymous method symbols
 126      *  that `own' an initializer block.
 127      */
 128     public static final int BLOCK            = 1<<20;
 129 
 130     /** Flag bit 21 is available. (used earlier to tag compiler-generated abstract methods that implement
 131      *  an interface method (Miranda methods)).
 132      */
 133 
 134     /** Flag is set for nested classes that do not access instance members
 135      *  or `this' of an outer class and therefore don't need to be passed
 136      *  a this$n reference.  This value is currently set only for anonymous
 137      *  classes in superclass constructor calls.
 138      *  todo: use this value for optimizing away this$n parameters in
 139      *  other cases.
 140      */
 141     public static final int NOOUTERTHIS  = 1<<22;
 142 
 143     /** Flag is set for package symbols if a package has a member or
 144      *  directory and therefore exists.


 203     /** Flag that marks a generated default constructor.
 204      */
 205     public static final long GENERATEDCONSTR   = 1L<<36;
 206 
 207     /** Flag that marks a hypothetical method that need not really be
 208      *  generated in the binary, but is present in the symbol table to
 209      *  simplify checking for erasure clashes - also used for 292 poly sig methods.
 210      */
 211     public static final long HYPOTHETICAL   = 1L<<37;
 212 
 213     /**
 214      * Flag that marks an internal proprietary class.
 215      */
 216     public static final long PROPRIETARY = 1L<<38;
 217 
 218     /**
 219      * Flag that marks a multi-catch parameter.
 220      */
 221     public static final long UNION = 1L<<39;
 222 
 223     // Flag bit (1L << 40) is available.
 224 
 225     /**
 226      * Flag that marks an 'effectively final' local variable.
 227      */
 228     public static final long EFFECTIVELY_FINAL = 1L<<41;
 229 
 230     /**
 231      * Flag that marks non-override equivalent methods with the same signature.
 232      */
 233     public static final long CLASH = 1L<<42;
 234 
 235     /**
 236      * Flag that marks either a default method or an interface containing default methods.
 237      */
 238     public static final long DEFAULT = 1L<<43;
 239 
 240     /**
 241      * Flag that marks class as auxiliary, ie a non-public class following
 242      * the public class in a source file, that could block implicit compilation.
 243      */
 244     public static final long AUXILIARY = 1L<<44;


 311     /**
 312      * Flag for synthesized default constructors of anonymous classes that have an enclosing expression.
 313      */
 314     public static final long ANONCONSTR_BASED = 1L<<57;
 315 
 316     /**
 317      * Flag that marks finalize block as body-only, should not be copied into catch clauses.
 318      * Used to implement try-with-resources.
 319      */
 320     public static final long BODY_ONLY_FINALIZE = 1L<<17; //blocks only
 321 
 322     /**
 323      * Flag to indicate the given ParamSymbol has a user-friendly name filled.
 324      */
 325     public static final long NAME_FILLED = 1L<<58; //ParamSymbols only
 326 
 327     /** Modifier masks.
 328      */
 329     public static final int
 330         AccessFlags           = PUBLIC | PROTECTED | PRIVATE,
 331         LocalClassFlags       = FINAL | ABSTRACT | STRICTFP | ENUM | SYNTHETIC,
 332         MemberClassFlags      = LocalClassFlags | INTERFACE | AccessFlags,
 333         ClassFlags            = LocalClassFlags | INTERFACE | PUBLIC | ANNOTATION,
 334         InterfaceVarFlags     = FINAL | STATIC | PUBLIC,
 335         VarFlags              = AccessFlags | FINAL | STATIC |
 336                                 VOLATILE | TRANSIENT | ENUM,
 337         ConstructorFlags      = AccessFlags,
 338         InterfaceMethodFlags  = ABSTRACT | PUBLIC,
 339         MethodFlags           = AccessFlags | ABSTRACT | STATIC | NATIVE |
 340                                 SYNCHRONIZED | FINAL | STRICTFP;
 341     public static final long
 342         ExtendedStandardFlags       = (long)StandardFlags | DEFAULT,
 343         ModifierFlags               = ((long)StandardFlags & ~INTERFACE) | DEFAULT,
 344         InterfaceMethodMask         = ABSTRACT | PRIVATE | STATIC | PUBLIC | STRICTFP | DEFAULT,
 345         AnnotationTypeElementMask   = ABSTRACT | PUBLIC,
 346         LocalVarFlags               = FINAL | PARAMETER,


 347         ReceiverParamFlags          = PARAMETER;
 348 
 349 
 350     public static Set<Modifier> asModifierSet(long flags) {
 351         Set<Modifier> modifiers = modifierSets.get(flags);
 352         if (modifiers == null) {
 353             modifiers = java.util.EnumSet.noneOf(Modifier.class);
 354             if (0 != (flags & PUBLIC))    modifiers.add(Modifier.PUBLIC);
 355             if (0 != (flags & PROTECTED)) modifiers.add(Modifier.PROTECTED);
 356             if (0 != (flags & PRIVATE))   modifiers.add(Modifier.PRIVATE);
 357             if (0 != (flags & ABSTRACT))  modifiers.add(Modifier.ABSTRACT);
 358             if (0 != (flags & STATIC))    modifiers.add(Modifier.STATIC);
 359             if (0 != (flags & FINAL))     modifiers.add(Modifier.FINAL);
 360             if (0 != (flags & TRANSIENT)) modifiers.add(Modifier.TRANSIENT);
 361             if (0 != (flags & VOLATILE))  modifiers.add(Modifier.VOLATILE);
 362             if (0 != (flags & SYNCHRONIZED))
 363                                           modifiers.add(Modifier.SYNCHRONIZED);
 364             if (0 != (flags & NATIVE))    modifiers.add(Modifier.NATIVE);
 365             if (0 != (flags & STRICTFP))  modifiers.add(Modifier.STRICTFP);
 366             if (0 != (flags & DEFAULT))   modifiers.add(Modifier.DEFAULT);

 367             modifiers = Collections.unmodifiableSet(modifiers);
 368             modifierSets.put(flags, modifiers);
 369         }
 370         return modifiers;
 371     }
 372 
 373     // Cache of modifier sets.
 374     private static final Map<Long, Set<Modifier>> modifierSets = new ConcurrentHashMap<>(64);
 375 
 376     public static boolean isStatic(Symbol symbol) {
 377         return (symbol.flags() & STATIC) != 0;
 378     }
 379 
 380     public static boolean isEnum(Symbol symbol) {
 381         return (symbol.flags() & ENUM) != 0;
 382     }
 383 
 384     public static boolean isConstant(Symbol.VarSymbol symbol) {
 385         return symbol.getConstValue() != null;
 386     }


 391         PRIVATE(Flags.PRIVATE),
 392         PROTECTED(Flags.PROTECTED),
 393         STATIC(Flags.STATIC),
 394         FINAL(Flags.FINAL),
 395         SYNCHRONIZED(Flags.SYNCHRONIZED),
 396         VOLATILE(Flags.VOLATILE),
 397         TRANSIENT(Flags.TRANSIENT),
 398         NATIVE(Flags.NATIVE),
 399         INTERFACE(Flags.INTERFACE),
 400         ABSTRACT(Flags.ABSTRACT),
 401         DEFAULT(Flags.DEFAULT),
 402         STRICTFP(Flags.STRICTFP),
 403         BRIDGE(Flags.BRIDGE),
 404         SYNTHETIC(Flags.SYNTHETIC),
 405         ANNOTATION(Flags.ANNOTATION),
 406         DEPRECATED(Flags.DEPRECATED),
 407         HASINIT(Flags.HASINIT),
 408         BLOCK(Flags.BLOCK),
 409         ENUM(Flags.ENUM),
 410         MANDATED(Flags.MANDATED),

 411         NOOUTERTHIS(Flags.NOOUTERTHIS),
 412         EXISTS(Flags.EXISTS),
 413         COMPOUND(Flags.COMPOUND),
 414         CLASS_SEEN(Flags.CLASS_SEEN),
 415         SOURCE_SEEN(Flags.SOURCE_SEEN),
 416         LOCKED(Flags.LOCKED),
 417         UNATTRIBUTED(Flags.UNATTRIBUTED),
 418         ANONCONSTR(Flags.ANONCONSTR),
 419         ACYCLIC(Flags.ACYCLIC),
 420         PARAMETER(Flags.PARAMETER),
 421         VARARGS(Flags.VARARGS),
 422         ACYCLIC_ANN(Flags.ACYCLIC_ANN),
 423         GENERATEDCONSTR(Flags.GENERATEDCONSTR),
 424         HYPOTHETICAL(Flags.HYPOTHETICAL),
 425         PROPRIETARY(Flags.PROPRIETARY),
 426         UNION(Flags.UNION),
 427         EFFECTIVELY_FINAL(Flags.EFFECTIVELY_FINAL),
 428         CLASH(Flags.CLASH),
 429         AUXILIARY(Flags.AUXILIARY),
 430         NOT_IN_PROFILE(Flags.NOT_IN_PROFILE),
 431         BAD_OVERRIDE(Flags.BAD_OVERRIDE),
 432         SIGNATURE_POLYMORPHIC(Flags.SIGNATURE_POLYMORPHIC),
 433         THROWS(Flags.THROWS),
 434         LAMBDA_METHOD(Flags.LAMBDA_METHOD),
 435         TYPE_TRANSLATED(Flags.TYPE_TRANSLATED),
 436         MODULE(Flags.MODULE),
 437         AUTOMATIC_MODULE(Flags.AUTOMATIC_MODULE),
 438         SYSTEM_MODULE(Flags.SYSTEM_MODULE),
 439         DEPRECATED_ANNOTATION(Flags.DEPRECATED_ANNOTATION),
 440         DEPRECATED_REMOVAL(Flags.DEPRECATED_REMOVAL),
 441         HAS_RESOURCE(Flags.HAS_RESOURCE),
 442         POTENTIALLY_AMBIGUOUS(Flags.POTENTIALLY_AMBIGUOUS),
 443         ANONCONSTR_BASED(Flags.ANONCONSTR_BASED),

 444         NAME_FILLED(Flags.NAME_FILLED);
 445 
 446         Flag(long flag) {
 447             this.value = flag;
 448             this.lowercaseName = StringUtils.toLowerCase(name());
 449         }
 450 
 451         @Override
 452         public String toString() {
 453             return lowercaseName;
 454         }
 455 
 456         final long value;
 457         final String lowercaseName;
 458     }
 459 
 460 }


  81     public static final int VOLATILE     = 1<<6;
  82     public static final int TRANSIENT    = 1<<7;
  83     public static final int NATIVE       = 1<<8;
  84     public static final int INTERFACE    = 1<<9;
  85     public static final int ABSTRACT     = 1<<10;
  86     public static final int STRICTFP     = 1<<11;
  87 
  88     /* Flag that marks a symbol synthetic, added in classfile v49.0. */
  89     public static final int SYNTHETIC    = 1<<12;
  90 
  91     /** Flag that marks attribute interfaces, added in classfile v49.0. */
  92     public static final int ANNOTATION   = 1<<13;
  93 
  94     /** An enumeration type or an enumeration constant, added in
  95      *  classfile v49.0. */
  96     public static final int ENUM         = 1<<14;
  97 
  98     /** Added in SE8, represents constructs implicitly declared in source. */
  99     public static final int MANDATED     = 1<<15;
 100 
 101     /** Marks a type as a value-type */
 102     public static final int VALUE        = 1<<16;
 103 
 104     public static final int StandardFlags = 0x0fff;
 105 
 106     // Because the following access flags are overloaded with other
 107     // bit positions, we translate them when reading and writing class
 108     // files into unique bits positions: ACC_SYNTHETIC <-> SYNTHETIC,
 109     // for example.
 110     public static final int ACC_SUPER    = 0x0020;
 111     public static final int ACC_BRIDGE   = 0x0040;
 112     public static final int ACC_VARARGS  = 0x0080;
 113     public static final int ACC_VALUE    = 0x0100;
 114     public static final int ACC_MODULE   = 0x8000;
 115 
 116     /*****************************************
 117      * Internal compiler flags (no bits in the lower 16).
 118      *****************************************/
 119 
 120     /** Flag is set if symbol is deprecated.  See also DEPRECATED_REMOVAL.
 121      */
 122     public static final int DEPRECATED   = 1<<17;
 123 
 124     /** Flag is set for a variable symbol if the variable's definition
 125      *  has an initializer part.
 126      */
 127     public static final int HASINIT          = 1<<18;
 128 
 129     /** Flag is set for a value based class.
 130      */
 131     public static final int VALUEBASED       = 1<<19;
 132 
 133     /** Flag is set for compiler-generated anonymous method symbols
 134      *  that `own' an initializer block.
 135      */
 136     public static final int BLOCK            = 1<<20;
 137 
 138     /** Flag bit 21 is available. (used earlier to tag compiler-generated abstract methods that implement
 139      *  an interface method (Miranda methods)).
 140      */
 141 
 142     /** Flag is set for nested classes that do not access instance members
 143      *  or `this' of an outer class and therefore don't need to be passed
 144      *  a this$n reference.  This value is currently set only for anonymous
 145      *  classes in superclass constructor calls.
 146      *  todo: use this value for optimizing away this$n parameters in
 147      *  other cases.
 148      */
 149     public static final int NOOUTERTHIS  = 1<<22;
 150 
 151     /** Flag is set for package symbols if a package has a member or
 152      *  directory and therefore exists.


 211     /** Flag that marks a generated default constructor.
 212      */
 213     public static final long GENERATEDCONSTR   = 1L<<36;
 214 
 215     /** Flag that marks a hypothetical method that need not really be
 216      *  generated in the binary, but is present in the symbol table to
 217      *  simplify checking for erasure clashes - also used for 292 poly sig methods.
 218      */
 219     public static final long HYPOTHETICAL   = 1L<<37;
 220 
 221     /**
 222      * Flag that marks an internal proprietary class.
 223      */
 224     public static final long PROPRIETARY = 1L<<38;
 225 
 226     /**
 227      * Flag that marks a multi-catch parameter.
 228      */
 229     public static final long UNION = 1L<<39;
 230 


 231     /**
 232      * Flag that marks an 'effectively final' local variable.
 233      */
 234     public static final long EFFECTIVELY_FINAL = 1L<<41;
 235 
 236     /**
 237      * Flag that marks non-override equivalent methods with the same signature.
 238      */
 239     public static final long CLASH = 1L<<42;
 240 
 241     /**
 242      * Flag that marks either a default method or an interface containing default methods.
 243      */
 244     public static final long DEFAULT = 1L<<43;
 245 
 246     /**
 247      * Flag that marks class as auxiliary, ie a non-public class following
 248      * the public class in a source file, that could block implicit compilation.
 249      */
 250     public static final long AUXILIARY = 1L<<44;


 317     /**
 318      * Flag for synthesized default constructors of anonymous classes that have an enclosing expression.
 319      */
 320     public static final long ANONCONSTR_BASED = 1L<<57;
 321 
 322     /**
 323      * Flag that marks finalize block as body-only, should not be copied into catch clauses.
 324      * Used to implement try-with-resources.
 325      */
 326     public static final long BODY_ONLY_FINALIZE = 1L<<17; //blocks only
 327 
 328     /**
 329      * Flag to indicate the given ParamSymbol has a user-friendly name filled.
 330      */
 331     public static final long NAME_FILLED = 1L<<58; //ParamSymbols only
 332 
 333     /** Modifier masks.
 334      */
 335     public static final int
 336         AccessFlags           = PUBLIC | PROTECTED | PRIVATE,
 337         LocalClassFlags       = FINAL | ABSTRACT | STRICTFP | ENUM | SYNTHETIC | VALUE,
 338         MemberClassFlags      = LocalClassFlags | INTERFACE | AccessFlags,
 339         ClassFlags            = LocalClassFlags | INTERFACE | PUBLIC | ANNOTATION,
 340         InterfaceVarFlags     = FINAL | STATIC | PUBLIC,


 341         ConstructorFlags      = AccessFlags,
 342         InterfaceMethodFlags  = ABSTRACT | PUBLIC,
 343         MethodFlags           = AccessFlags | ABSTRACT | STATIC | NATIVE |
 344                                 SYNCHRONIZED | FINAL | STRICTFP;
 345     public static final long
 346         ExtendedStandardFlags       = (long)StandardFlags | DEFAULT | VALUE,
 347         ModifierFlags               = ((long)StandardFlags & ~INTERFACE) | DEFAULT,
 348         InterfaceMethodMask         = ABSTRACT | PRIVATE | STATIC | PUBLIC | STRICTFP | DEFAULT,
 349         AnnotationTypeElementMask   = ABSTRACT | PUBLIC,
 350         LocalVarFlags               = FINAL | PARAMETER,
 351         VarFlags              = AccessFlags | FINAL | STATIC |
 352                                 VOLATILE | TRANSIENT | ENUM,
 353         ReceiverParamFlags          = PARAMETER;
 354 
 355 
 356     public static Set<Modifier> asModifierSet(long flags) {
 357         Set<Modifier> modifiers = modifierSets.get(flags);
 358         if (modifiers == null) {
 359             modifiers = java.util.EnumSet.noneOf(Modifier.class);
 360             if (0 != (flags & PUBLIC))    modifiers.add(Modifier.PUBLIC);
 361             if (0 != (flags & PROTECTED)) modifiers.add(Modifier.PROTECTED);
 362             if (0 != (flags & PRIVATE))   modifiers.add(Modifier.PRIVATE);
 363             if (0 != (flags & ABSTRACT))  modifiers.add(Modifier.ABSTRACT);
 364             if (0 != (flags & STATIC))    modifiers.add(Modifier.STATIC);
 365             if (0 != (flags & FINAL))     modifiers.add(Modifier.FINAL);
 366             if (0 != (flags & TRANSIENT)) modifiers.add(Modifier.TRANSIENT);
 367             if (0 != (flags & VOLATILE))  modifiers.add(Modifier.VOLATILE);
 368             if (0 != (flags & SYNCHRONIZED))
 369                                           modifiers.add(Modifier.SYNCHRONIZED);
 370             if (0 != (flags & NATIVE))    modifiers.add(Modifier.NATIVE);
 371             if (0 != (flags & STRICTFP))  modifiers.add(Modifier.STRICTFP);
 372             if (0 != (flags & DEFAULT))   modifiers.add(Modifier.DEFAULT);
 373             if (0 != (flags & VALUE))     modifiers.add(Modifier.VALUE);
 374             modifiers = Collections.unmodifiableSet(modifiers);
 375             modifierSets.put(flags, modifiers);
 376         }
 377         return modifiers;
 378     }
 379 
 380     // Cache of modifier sets.
 381     private static final Map<Long, Set<Modifier>> modifierSets = new ConcurrentHashMap<>(64);
 382 
 383     public static boolean isStatic(Symbol symbol) {
 384         return (symbol.flags() & STATIC) != 0;
 385     }
 386 
 387     public static boolean isEnum(Symbol symbol) {
 388         return (symbol.flags() & ENUM) != 0;
 389     }
 390 
 391     public static boolean isConstant(Symbol.VarSymbol symbol) {
 392         return symbol.getConstValue() != null;
 393     }


 398         PRIVATE(Flags.PRIVATE),
 399         PROTECTED(Flags.PROTECTED),
 400         STATIC(Flags.STATIC),
 401         FINAL(Flags.FINAL),
 402         SYNCHRONIZED(Flags.SYNCHRONIZED),
 403         VOLATILE(Flags.VOLATILE),
 404         TRANSIENT(Flags.TRANSIENT),
 405         NATIVE(Flags.NATIVE),
 406         INTERFACE(Flags.INTERFACE),
 407         ABSTRACT(Flags.ABSTRACT),
 408         DEFAULT(Flags.DEFAULT),
 409         STRICTFP(Flags.STRICTFP),
 410         BRIDGE(Flags.BRIDGE),
 411         SYNTHETIC(Flags.SYNTHETIC),
 412         ANNOTATION(Flags.ANNOTATION),
 413         DEPRECATED(Flags.DEPRECATED),
 414         HASINIT(Flags.HASINIT),
 415         BLOCK(Flags.BLOCK),
 416         ENUM(Flags.ENUM),
 417         MANDATED(Flags.MANDATED),
 418         INLINE(Flags.VALUE),
 419         NOOUTERTHIS(Flags.NOOUTERTHIS),
 420         EXISTS(Flags.EXISTS),
 421         COMPOUND(Flags.COMPOUND),
 422         CLASS_SEEN(Flags.CLASS_SEEN),
 423         SOURCE_SEEN(Flags.SOURCE_SEEN),
 424         LOCKED(Flags.LOCKED),
 425         UNATTRIBUTED(Flags.UNATTRIBUTED),
 426         ANONCONSTR(Flags.ANONCONSTR),
 427         ACYCLIC(Flags.ACYCLIC),
 428         PARAMETER(Flags.PARAMETER),
 429         VARARGS(Flags.VARARGS),
 430         ACYCLIC_ANN(Flags.ACYCLIC_ANN),
 431         GENERATEDCONSTR(Flags.GENERATEDCONSTR),
 432         HYPOTHETICAL(Flags.HYPOTHETICAL),
 433         PROPRIETARY(Flags.PROPRIETARY),
 434         UNION(Flags.UNION),
 435         EFFECTIVELY_FINAL(Flags.EFFECTIVELY_FINAL),
 436         CLASH(Flags.CLASH),
 437         AUXILIARY(Flags.AUXILIARY),
 438         NOT_IN_PROFILE(Flags.NOT_IN_PROFILE),
 439         BAD_OVERRIDE(Flags.BAD_OVERRIDE),
 440         SIGNATURE_POLYMORPHIC(Flags.SIGNATURE_POLYMORPHIC),
 441         THROWS(Flags.THROWS),
 442         LAMBDA_METHOD(Flags.LAMBDA_METHOD),
 443         TYPE_TRANSLATED(Flags.TYPE_TRANSLATED),
 444         MODULE(Flags.MODULE),
 445         AUTOMATIC_MODULE(Flags.AUTOMATIC_MODULE),
 446         SYSTEM_MODULE(Flags.SYSTEM_MODULE),
 447         DEPRECATED_ANNOTATION(Flags.DEPRECATED_ANNOTATION),
 448         DEPRECATED_REMOVAL(Flags.DEPRECATED_REMOVAL),
 449         HAS_RESOURCE(Flags.HAS_RESOURCE),
 450         POTENTIALLY_AMBIGUOUS(Flags.POTENTIALLY_AMBIGUOUS),
 451         ANONCONSTR_BASED(Flags.ANONCONSTR_BASED),
 452         VALUEBASED(Flags.VALUEBASED),
 453         NAME_FILLED(Flags.NAME_FILLED);
 454 
 455         Flag(long flag) {
 456             this.value = flag;
 457             this.lowercaseName = StringUtils.toLowerCase(name());
 458         }
 459 
 460         @Override
 461         public String toString() {
 462             return lowercaseName;
 463         }
 464 
 465         final long value;
 466         final String lowercaseName;
 467     }
 468 
 469 }
< prev index next >