< 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.
145      */
146     public static final int EXISTS           = 1<<23;
147 
148     /** Flag is set for compiler-generated compound classes
149      *  representing multiple variable bounds
150      */
151     public static final int COMPOUND     = 1<<24;
152 

378     /** Flag is set for compiler-generated record members, it could be applied to
379      *  accessors and fields
380      */
381     public static final int GENERATED_MEMBER = 1<<24; // MethodSymbols and VarSymbols
382 
383     /**
384      * Flag to indicate sealed class/interface declaration.
385      */
386     public static final long SEALED = 1L<<62; // ClassSymbols
387 
388     /**
389      * Flag to indicate that the class/interface was declared with the non-sealed modifier.
390      */
391     public static final long NON_SEALED = 1L<<63; // ClassSymbols
392 
393 
394     /** Modifier masks.
395      */
396     public static final int
397         AccessFlags                       = PUBLIC | PROTECTED | PRIVATE,
398         LocalClassFlags                   = FINAL | ABSTRACT | STRICTFP | ENUM | SYNTHETIC,
399         StaticLocalFlags                  = LocalClassFlags | STATIC | INTERFACE,
400         MemberClassFlags                  = LocalClassFlags | INTERFACE | AccessFlags,
401         MemberStaticClassFlags            = MemberClassFlags | STATIC,
402         ClassFlags                        = LocalClassFlags | INTERFACE | PUBLIC | ANNOTATION,
403         InterfaceVarFlags                 = FINAL | STATIC | PUBLIC,
404         VarFlags                          = AccessFlags | FINAL | STATIC |
405                                             VOLATILE | TRANSIENT | ENUM,
406         ConstructorFlags                  = AccessFlags,
407         InterfaceMethodFlags              = ABSTRACT | PUBLIC,
408         MethodFlags                       = AccessFlags | ABSTRACT | STATIC | NATIVE |
409                                             SYNCHRONIZED | FINAL | STRICTFP,
410         RecordMethodFlags                 = AccessFlags | ABSTRACT | STATIC |
411                                             SYNCHRONIZED | FINAL | STRICTFP;

412     public static final long
413         ExtendedStandardFlags             = (long)StandardFlags | DEFAULT | SEALED | NON_SEALED,
414         ExtendedMemberClassFlags          = (long)MemberClassFlags | SEALED | NON_SEALED,
415         ExtendedMemberStaticClassFlags    = (long) MemberStaticClassFlags | SEALED | NON_SEALED,
416         ExtendedClassFlags                = (long)ClassFlags | SEALED | NON_SEALED,
417         ModifierFlags                     = ((long)StandardFlags & ~INTERFACE) | DEFAULT | SEALED | NON_SEALED,


418         InterfaceMethodMask               = ABSTRACT | PRIVATE | STATIC | PUBLIC | STRICTFP | DEFAULT,
419         AnnotationTypeElementMask         = ABSTRACT | PUBLIC,
420         LocalVarFlags                     = FINAL | PARAMETER,
421         ReceiverParamFlags                = PARAMETER;
422 
423     public static Set<Modifier> asModifierSet(long flags) {
424         Set<Modifier> modifiers = modifierSets.get(flags);
425         if (modifiers == null) {
426             modifiers = java.util.EnumSet.noneOf(Modifier.class);
427             if (0 != (flags & PUBLIC))    modifiers.add(Modifier.PUBLIC);
428             if (0 != (flags & PROTECTED)) modifiers.add(Modifier.PROTECTED);
429             if (0 != (flags & PRIVATE))   modifiers.add(Modifier.PRIVATE);
430             if (0 != (flags & ABSTRACT))  modifiers.add(Modifier.ABSTRACT);
431             if (0 != (flags & STATIC))    modifiers.add(Modifier.STATIC);
432             if (0 != (flags & SEALED))    modifiers.add(Modifier.SEALED);
433             if (0 != (flags & NON_SEALED))
434                                           modifiers.add(Modifier.NON_SEALED);
435             if (0 != (flags & FINAL))     modifiers.add(Modifier.FINAL);
436             if (0 != (flags & TRANSIENT)) modifiers.add(Modifier.TRANSIENT);
437             if (0 != (flags & VOLATILE))  modifiers.add(Modifier.VOLATILE);
438             if (0 != (flags & SYNCHRONIZED))
439                                           modifiers.add(Modifier.SYNCHRONIZED);
440             if (0 != (flags & NATIVE))    modifiers.add(Modifier.NATIVE);
441             if (0 != (flags & STRICTFP))  modifiers.add(Modifier.STRICTFP);
442             if (0 != (flags & DEFAULT))   modifiers.add(Modifier.DEFAULT);


443             modifiers = Collections.unmodifiableSet(modifiers);
444             modifierSets.put(flags, modifiers);
445         }
446         return modifiers;
447     }
448 
449     // Cache of modifier sets.
450     private static final Map<Long, Set<Modifier>> modifierSets = new ConcurrentHashMap<>(64);
451 
452     public static boolean isStatic(Symbol symbol) {
453         return (symbol.flags() & STATIC) != 0;
454     }
455 
456     public static boolean isEnum(Symbol symbol) {
457         return (symbol.flags() & ENUM) != 0;
458     }
459 
460     public static boolean isConstant(Symbol.VarSymbol symbol) {
461         return symbol.getConstValue() != null;
462     }

464 
465     public enum Flag {
466         PUBLIC(Flags.PUBLIC),
467         PRIVATE(Flags.PRIVATE),
468         PROTECTED(Flags.PROTECTED),
469         STATIC(Flags.STATIC),
470         FINAL(Flags.FINAL),
471         SYNCHRONIZED(Flags.SYNCHRONIZED),
472         VOLATILE(Flags.VOLATILE),
473         TRANSIENT(Flags.TRANSIENT),
474         NATIVE(Flags.NATIVE),
475         INTERFACE(Flags.INTERFACE),
476         ABSTRACT(Flags.ABSTRACT),
477         DEFAULT(Flags.DEFAULT),
478         STRICTFP(Flags.STRICTFP),
479         BRIDGE(Flags.BRIDGE),
480         SYNTHETIC(Flags.SYNTHETIC),
481         ANNOTATION(Flags.ANNOTATION),
482         DEPRECATED(Flags.DEPRECATED),
483         HASINIT(Flags.HASINIT),








484         BLOCK(Flags.BLOCK),
485         ENUM(Flags.ENUM),
486         MANDATED(Flags.MANDATED),


487         NOOUTERTHIS(Flags.NOOUTERTHIS),
488         EXISTS(Flags.EXISTS),
489         COMPOUND(Flags.COMPOUND),
490         CLASS_SEEN(Flags.CLASS_SEEN),
491         SOURCE_SEEN(Flags.SOURCE_SEEN),
492         LOCKED(Flags.LOCKED),
493         UNATTRIBUTED(Flags.UNATTRIBUTED),
494         ANONCONSTR(Flags.ANONCONSTR),
495         ACYCLIC(Flags.ACYCLIC),
496         PARAMETER(Flags.PARAMETER),
497         VARARGS(Flags.VARARGS),
498         ACYCLIC_ANN(Flags.ACYCLIC_ANN),
499         GENERATEDCONSTR(Flags.GENERATEDCONSTR),
500         HYPOTHETICAL(Flags.HYPOTHETICAL),
501         PROPRIETARY(Flags.PROPRIETARY),
502         UNION(Flags.UNION),
503         EFFECTIVELY_FINAL(Flags.EFFECTIVELY_FINAL),
504         CLASH(Flags.CLASH),
505         AUXILIARY(Flags.AUXILIARY),
506         NOT_IN_PROFILE(Flags.NOT_IN_PROFILE),

 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 primitive class. We can't reuse the class file encoding (ACC_PRIMITIVE)
102      * since the latter shares its value (0x800) with ACC_STRICT (javac speak: STRICT_FP) and while
103      * STRICT_FP is not a valid flag for a class in the class file level, javac's ASTs flag a class
104      * as being STRICT_FP so as to propagate the FP strictness to methods of the class thereby causing
105      * a clash */
106     public static final int PRIMITIVE_CLASS  = 1<<16;
107 
108     public static final int StandardFlags = 0x0fff;
109 
110     // Because the following access flags are overloaded with other
111     // bit positions, we translate them when reading and writing class
112     // files into unique bits positions: ACC_SYNTHETIC <-> SYNTHETIC,
113     // for example.
114     public static final int ACC_IDENTITY = 0x0020;
115     public static final int ACC_VALUE    = 0x0040;
116     public static final int ACC_BRIDGE   = 0x0040;
117     public static final int ACC_VARARGS  = 0x0080;
118     public static final int ACC_PRIMITIVE = 0x0800;
119     public static final int ACC_MODULE   = 0x8000;
120 
121     /*****************************************
122      * Internal compiler flags (no bits in the lower 16).
123      *****************************************/
124 
125     /** Flag is set if symbol is deprecated.  See also DEPRECATED_REMOVAL.
126      */
127     public static final int DEPRECATED   = 1<<17;
128 
129     /** Flag is set for a variable symbol if the variable's definition
130      *  has an initializer part.
131      */
132     public static final int HASINIT          = 1<<18;
133 
134     /** Flag is set for a class symbol if it defines one or more non-empty
135      *  instance initializer block(s). This is relevenat only for class symbols
136      *  that originate from source types. For binary types the instance initializer
137      *  blocks are "normalized" into the constructors.
138      */
139     public static final int HASINITBLOCK         = 1<<18;
140 
141     /** Flag is set for a method symbol if it is an empty no-arg ctor.
142      *  i.e. one that simply returns (jlO) or merely chains to a super's
143      *  no-arg ctor
144      */
145     public static final int EMPTYNOARGCONSTR         = 1<<18;
146 
147     /** Flag is set for a class or interface whose instances have identity
148      * i.e. class/interface declarations that are expressly declared with
149      * the modifier `identity' or (b) any concrete class not declared with the
150      * modifier `value' (c) abstract class not declared `value' but meets various
151      * stipulations (d) older class files with ACC_SUPER bit set
152      */
153     public static final int IDENTITY_TYPE            = 1<<19;
154 
155     /** Flag is set for compiler-generated anonymous method symbols
156      *  that `own' an initializer block.
157      */
158     public static final int BLOCK            = 1<<20;
159 
160     /** Marks a type as a value class */
161     public static final int VALUE_CLASS  = 1<<21;

162 
163     /** Flag is set for nested classes that do not access instance members
164      *  or `this' of an outer class and therefore don't need to be passed
165      *  a this$n reference.  This value is currently set only for anonymous
166      *  classes in superclass constructor calls.
167      *  todo: use this value for optimizing away this$n parameters in
168      *  other cases.
169      */
170     public static final int NOOUTERTHIS  = 1<<22;
171 
172     /** Flag is set for package symbols if a package has a member or
173      *  directory and therefore exists.
174      */
175     public static final int EXISTS           = 1<<23;
176 
177     /** Flag is set for compiler-generated compound classes
178      *  representing multiple variable bounds
179      */
180     public static final int COMPOUND     = 1<<24;
181 

407     /** Flag is set for compiler-generated record members, it could be applied to
408      *  accessors and fields
409      */
410     public static final int GENERATED_MEMBER = 1<<24; // MethodSymbols and VarSymbols
411 
412     /**
413      * Flag to indicate sealed class/interface declaration.
414      */
415     public static final long SEALED = 1L<<62; // ClassSymbols
416 
417     /**
418      * Flag to indicate that the class/interface was declared with the non-sealed modifier.
419      */
420     public static final long NON_SEALED = 1L<<63; // ClassSymbols
421 
422 
423     /** Modifier masks.
424      */
425     public static final int
426         AccessFlags                       = PUBLIC | PROTECTED | PRIVATE,
427         LocalClassFlags                   = FINAL | ABSTRACT | STRICTFP | ENUM | SYNTHETIC | ACC_IDENTITY,
428         StaticLocalClassFlags             = LocalClassFlags | STATIC | INTERFACE,
429         MemberClassFlags                  = LocalClassFlags | INTERFACE | AccessFlags,
430         MemberStaticClassFlags            = MemberClassFlags | STATIC,
431         ClassFlags                        = LocalClassFlags | INTERFACE | PUBLIC | ANNOTATION,
432         InterfaceVarFlags                 = FINAL | STATIC | PUBLIC,
433         VarFlags                          = AccessFlags | FINAL | STATIC |
434                                             VOLATILE | TRANSIENT | ENUM,
435         ConstructorFlags                  = AccessFlags,
436         InterfaceMethodFlags              = ABSTRACT | PUBLIC,
437         MethodFlags                       = AccessFlags | ABSTRACT | STATIC | NATIVE |
438                                             SYNCHRONIZED | FINAL | STRICTFP,
439         RecordMethodFlags                 = AccessFlags | ABSTRACT | STATIC |
440                                             SYNCHRONIZED | FINAL | STRICTFP,
441         AdjustedClassFlags                = ClassFlags | ACC_PRIMITIVE | ACC_VALUE;
442     public static final long
443         ExtendedStandardFlags             = (long)StandardFlags | DEFAULT | SEALED | NON_SEALED | PRIMITIVE_CLASS | VALUE_CLASS,
444         ExtendedMemberClassFlags          = (long)MemberClassFlags | SEALED | NON_SEALED | PRIMITIVE_CLASS | VALUE_CLASS,
445         ExtendedMemberStaticClassFlags    = (long) MemberStaticClassFlags | SEALED | NON_SEALED | PRIMITIVE_CLASS | VALUE_CLASS,
446         ExtendedClassFlags                = (long)ClassFlags | SEALED | NON_SEALED | PRIMITIVE_CLASS | VALUE_CLASS,
447         ExtendedLocalClassFlags           = (long) LocalClassFlags | PRIMITIVE_CLASS | VALUE_CLASS,
448         ExtendedStaticLocalClassFlags     = (long) StaticLocalClassFlags | PRIMITIVE_CLASS | VALUE_CLASS,
449         ModifierFlags                     = ((long)StandardFlags & ~INTERFACE) | DEFAULT | SEALED | NON_SEALED | PRIMITIVE_CLASS | VALUE_CLASS,
450         InterfaceMethodMask               = ABSTRACT | PRIVATE | STATIC | PUBLIC | STRICTFP | DEFAULT,
451         AnnotationTypeElementMask         = ABSTRACT | PUBLIC,
452         LocalVarFlags                     = FINAL | PARAMETER,
453         ReceiverParamFlags                = PARAMETER;
454 
455     public static Set<Modifier> asModifierSet(long flags) {
456         Set<Modifier> modifiers = modifierSets.get(flags);
457         if (modifiers == null) {
458             modifiers = java.util.EnumSet.noneOf(Modifier.class);
459             if (0 != (flags & PUBLIC))    modifiers.add(Modifier.PUBLIC);
460             if (0 != (flags & PROTECTED)) modifiers.add(Modifier.PROTECTED);
461             if (0 != (flags & PRIVATE))   modifiers.add(Modifier.PRIVATE);
462             if (0 != (flags & ABSTRACT))  modifiers.add(Modifier.ABSTRACT);
463             if (0 != (flags & STATIC))    modifiers.add(Modifier.STATIC);
464             if (0 != (flags & SEALED))    modifiers.add(Modifier.SEALED);
465             if (0 != (flags & NON_SEALED))
466                                           modifiers.add(Modifier.NON_SEALED);
467             if (0 != (flags & FINAL))     modifiers.add(Modifier.FINAL);
468             if (0 != (flags & TRANSIENT)) modifiers.add(Modifier.TRANSIENT);
469             if (0 != (flags & VOLATILE))  modifiers.add(Modifier.VOLATILE);
470             if (0 != (flags & SYNCHRONIZED))
471                                           modifiers.add(Modifier.SYNCHRONIZED);
472             if (0 != (flags & NATIVE))    modifiers.add(Modifier.NATIVE);
473             if (0 != (flags & STRICTFP))  modifiers.add(Modifier.STRICTFP);
474             if (0 != (flags & DEFAULT))   modifiers.add(Modifier.DEFAULT);
475             if (0 != (flags & PRIMITIVE_CLASS))     modifiers.add(Modifier.PRIMITIVE);
476             if (0 != (flags & VALUE_CLASS))     modifiers.add(Modifier.VALUE);
477             modifiers = Collections.unmodifiableSet(modifiers);
478             modifierSets.put(flags, modifiers);
479         }
480         return modifiers;
481     }
482 
483     // Cache of modifier sets.
484     private static final Map<Long, Set<Modifier>> modifierSets = new ConcurrentHashMap<>(64);
485 
486     public static boolean isStatic(Symbol symbol) {
487         return (symbol.flags() & STATIC) != 0;
488     }
489 
490     public static boolean isEnum(Symbol symbol) {
491         return (symbol.flags() & ENUM) != 0;
492     }
493 
494     public static boolean isConstant(Symbol.VarSymbol symbol) {
495         return symbol.getConstValue() != null;
496     }

498 
499     public enum Flag {
500         PUBLIC(Flags.PUBLIC),
501         PRIVATE(Flags.PRIVATE),
502         PROTECTED(Flags.PROTECTED),
503         STATIC(Flags.STATIC),
504         FINAL(Flags.FINAL),
505         SYNCHRONIZED(Flags.SYNCHRONIZED),
506         VOLATILE(Flags.VOLATILE),
507         TRANSIENT(Flags.TRANSIENT),
508         NATIVE(Flags.NATIVE),
509         INTERFACE(Flags.INTERFACE),
510         ABSTRACT(Flags.ABSTRACT),
511         DEFAULT(Flags.DEFAULT),
512         STRICTFP(Flags.STRICTFP),
513         BRIDGE(Flags.BRIDGE),
514         SYNTHETIC(Flags.SYNTHETIC),
515         ANNOTATION(Flags.ANNOTATION),
516         DEPRECATED(Flags.DEPRECATED),
517         HASINIT(Flags.HASINIT),
518         HASINITBLOCK(Flags.HASINITBLOCK),
519         EMPTYNOARGCONSTR(Flags.EMPTYNOARGCONSTR),
520         IDENTITY_TYPE(Flags.IDENTITY_TYPE) {
521             @Override
522             public String toString() {
523                 return "identity";
524             }
525         },
526         BLOCK(Flags.BLOCK),
527         ENUM(Flags.ENUM),
528         MANDATED(Flags.MANDATED),
529         PRIMITIVE(Flags.PRIMITIVE_CLASS),
530         VALUE(Flags.VALUE_CLASS),
531         NOOUTERTHIS(Flags.NOOUTERTHIS),
532         EXISTS(Flags.EXISTS),
533         COMPOUND(Flags.COMPOUND),
534         CLASS_SEEN(Flags.CLASS_SEEN),
535         SOURCE_SEEN(Flags.SOURCE_SEEN),
536         LOCKED(Flags.LOCKED),
537         UNATTRIBUTED(Flags.UNATTRIBUTED),
538         ANONCONSTR(Flags.ANONCONSTR),
539         ACYCLIC(Flags.ACYCLIC),
540         PARAMETER(Flags.PARAMETER),
541         VARARGS(Flags.VARARGS),
542         ACYCLIC_ANN(Flags.ACYCLIC_ANN),
543         GENERATEDCONSTR(Flags.GENERATEDCONSTR),
544         HYPOTHETICAL(Flags.HYPOTHETICAL),
545         PROPRIETARY(Flags.PROPRIETARY),
546         UNION(Flags.UNION),
547         EFFECTIVELY_FINAL(Flags.EFFECTIVELY_FINAL),
548         CLASH(Flags.CLASH),
549         AUXILIARY(Flags.AUXILIARY),
550         NOT_IN_PROFILE(Flags.NOT_IN_PROFILE),
< prev index next >