88
89 /* Flag that marks a symbol synthetic, added in classfile v49.0. */
90 public static final int SYNTHETIC = 1<<12;
91
92 /** Flag that marks attribute interfaces, added in classfile v49.0. */
93 public static final int ANNOTATION = 1<<13;
94
95 /** An enumeration type or an enumeration constant, added in
96 * classfile v49.0. */
97 public static final int ENUM = 1<<14;
98
99 /** Added in SE8, represents constructs implicitly declared in source. */
100 public static final int MANDATED = 1<<15;
101
102 public static final int StandardFlags = 0x0fff;
103
104 // Because the following access flags are overloaded with other
105 // bit positions, we translate them when reading and writing class
106 // files into unique bits positions: ACC_SYNTHETIC <-> SYNTHETIC,
107 // for example.
108 public static final int ACC_SUPER = 0x0020;
109 public static final int ACC_BRIDGE = 0x0040;
110 public static final int ACC_VARARGS = 0x0080;
111 public static final int ACC_MODULE = 0x8000;
112
113 /*****************************************
114 * Internal compiler flags (no bits in the lower 16).
115 *****************************************/
116
117 /** Flag is set if symbol is deprecated. See also DEPRECATED_REMOVAL.
118 */
119 public static final int DEPRECATED = 1<<17;
120
121 /** Flag is set for a variable symbol if the variable's definition
122 * has an initializer part.
123 */
124 public static final int HASINIT = 1<<18;
125
126 /** Class is an implicitly declared top level class.
127 */
128 public static final int IMPLICIT_CLASS = 1<<19;
129
130 /** Flag is set for compiler-generated anonymous method symbols
131 * that `own' an initializer block.
132 */
133 public static final int BLOCK = 1<<20;
134
135 /** Flag is set for ClassSymbols that are being compiled from source.
136 */
137 public static final int FROM_SOURCE = 1<<21; //ClassSymbols
138
139 /** Flag is set for nested classes that do not access instance members
140 * or `this' of an outer class and therefore don't need to be passed
141 * a this$n reference. This value is currently set only for anonymous
142 * classes in superclass constructor calls.
143 * todo: use this value for optimizing away this$n parameters in
144 * other cases.
145 */
146 public static final int NOOUTERTHIS = 1<<22;
147
148 /** Flag is set for package symbols if a package has a member or
149 * directory and therefore exists.
150 */
151 public static final int EXISTS = 1<<23;
152
153 /** Flag is set for compiler-generated compound classes
154 * representing multiple variable bounds
382 /** Flag is set for compiler-generated record members, it could be applied to
383 * accessors and fields
384 */
385 public static final int GENERATED_MEMBER = 1<<24; // MethodSymbols and VarSymbols
386
387 /**
388 * Flag to indicate sealed class/interface declaration.
389 */
390 public static final long SEALED = 1L<<62; // ClassSymbols
391
392 /**
393 * Flag to indicate restricted method declaration.
394 */
395 public static final long RESTRICTED = 1L<<62; // MethodSymbols
396
397 /**
398 * Flag to indicate that the class/interface was declared with the non-sealed modifier.
399 */
400 public static final long NON_SEALED = 1L<<63; // ClassSymbols
401
402 /**
403 * Describe modifier flags as they might appear in source code, i.e.,
404 * separated by spaces and in the order suggested by JLS 8.1.1.
405 */
406 public static String toSource(long flags) {
407 return asModifierSet(flags).stream()
408 .map(Modifier::toString)
409 .collect(Collectors.joining(" "));
410 }
411
412 /** Modifier masks.
413 */
414 public static final int
415 AccessFlags = PUBLIC | PROTECTED | PRIVATE,
416 LocalClassFlags = FINAL | ABSTRACT | STRICTFP | ENUM | SYNTHETIC,
417 StaticLocalFlags = LocalClassFlags | STATIC | INTERFACE,
418 MemberClassFlags = LocalClassFlags | INTERFACE | AccessFlags,
419 MemberStaticClassFlags = MemberClassFlags | STATIC,
420 ClassFlags = LocalClassFlags | INTERFACE | PUBLIC | ANNOTATION,
421 InterfaceVarFlags = FINAL | STATIC | PUBLIC,
422 VarFlags = AccessFlags | FINAL | STATIC |
423 VOLATILE | TRANSIENT | ENUM,
424 ConstructorFlags = AccessFlags,
425 InterfaceMethodFlags = ABSTRACT | PUBLIC,
426 MethodFlags = AccessFlags | ABSTRACT | STATIC | NATIVE |
427 SYNCHRONIZED | FINAL | STRICTFP,
428 RecordMethodFlags = AccessFlags | ABSTRACT | STATIC |
429 SYNCHRONIZED | FINAL | STRICTFP;
430 public static final long
431 ExtendedStandardFlags = (long)StandardFlags | DEFAULT | SEALED | NON_SEALED,
432 ExtendedMemberClassFlags = (long)MemberClassFlags | SEALED | NON_SEALED,
433 ExtendedMemberStaticClassFlags = (long) MemberStaticClassFlags | SEALED | NON_SEALED,
434 ExtendedClassFlags = (long)ClassFlags | SEALED | NON_SEALED,
435 ModifierFlags = ((long)StandardFlags & ~INTERFACE) | DEFAULT | SEALED | NON_SEALED,
436 InterfaceMethodMask = ABSTRACT | PRIVATE | STATIC | PUBLIC | STRICTFP | DEFAULT,
437 AnnotationTypeElementMask = ABSTRACT | PUBLIC,
438 LocalVarFlags = FINAL | PARAMETER,
439 ReceiverParamFlags = PARAMETER;
440
441 public static Set<Modifier> asModifierSet(long flags) {
442 Set<Modifier> modifiers = modifierSets.get(flags);
443 if (modifiers == null) {
444 modifiers = java.util.EnumSet.noneOf(Modifier.class);
445 if (0 != (flags & PUBLIC)) modifiers.add(Modifier.PUBLIC);
446 if (0 != (flags & PROTECTED)) modifiers.add(Modifier.PROTECTED);
447 if (0 != (flags & PRIVATE)) modifiers.add(Modifier.PRIVATE);
448 if (0 != (flags & ABSTRACT)) modifiers.add(Modifier.ABSTRACT);
449 if (0 != (flags & STATIC)) modifiers.add(Modifier.STATIC);
450 if (0 != (flags & SEALED)) modifiers.add(Modifier.SEALED);
451 if (0 != (flags & NON_SEALED))
452 modifiers.add(Modifier.NON_SEALED);
453 if (0 != (flags & FINAL)) modifiers.add(Modifier.FINAL);
454 if (0 != (flags & TRANSIENT)) modifiers.add(Modifier.TRANSIENT);
455 if (0 != (flags & VOLATILE)) modifiers.add(Modifier.VOLATILE);
456 if (0 != (flags & SYNCHRONIZED))
457 modifiers.add(Modifier.SYNCHRONIZED);
458 if (0 != (flags & NATIVE)) modifiers.add(Modifier.NATIVE);
459 if (0 != (flags & STRICTFP)) modifiers.add(Modifier.STRICTFP);
460 if (0 != (flags & DEFAULT)) modifiers.add(Modifier.DEFAULT);
461 modifiers = Collections.unmodifiableSet(modifiers);
462 modifierSets.put(flags, modifiers);
463 }
464 return modifiers;
465 }
466
467 // Cache of modifier sets.
468 private static final Map<Long, Set<Modifier>> modifierSets = new ConcurrentHashMap<>(64);
469
470 public static boolean isStatic(Symbol symbol) {
471 return (symbol.flags() & STATIC) != 0;
472 }
473
474 public static boolean isEnum(Symbol symbol) {
475 return (symbol.flags() & ENUM) != 0;
476 }
477
478 public static boolean isConstant(Symbol.VarSymbol symbol) {
479 return symbol.getConstValue() != null;
480 }
481
482
483 public enum Flag {
484 PUBLIC(Flags.PUBLIC),
485 PRIVATE(Flags.PRIVATE),
486 PROTECTED(Flags.PROTECTED),
487 STATIC(Flags.STATIC),
488 FINAL(Flags.FINAL),
489 SYNCHRONIZED(Flags.SYNCHRONIZED),
490 VOLATILE(Flags.VOLATILE),
491 TRANSIENT(Flags.TRANSIENT),
492 NATIVE(Flags.NATIVE),
493 INTERFACE(Flags.INTERFACE),
494 ABSTRACT(Flags.ABSTRACT),
495 DEFAULT(Flags.DEFAULT),
496 STRICTFP(Flags.STRICTFP),
497 BRIDGE(Flags.BRIDGE),
498 SYNTHETIC(Flags.SYNTHETIC),
499 ANNOTATION(Flags.ANNOTATION),
500 DEPRECATED(Flags.DEPRECATED),
501 HASINIT(Flags.HASINIT),
502 IMPLICIT_CLASS(Flags.IMPLICIT_CLASS),
503 BLOCK(Flags.BLOCK),
504 FROM_SOURCE(Flags.FROM_SOURCE),
505 ENUM(Flags.ENUM),
506 MANDATED(Flags.MANDATED),
507 NOOUTERTHIS(Flags.NOOUTERTHIS),
508 EXISTS(Flags.EXISTS),
509 COMPOUND(Flags.COMPOUND),
510 CLASS_SEEN(Flags.CLASS_SEEN),
511 SOURCE_SEEN(Flags.SOURCE_SEEN),
512 LOCKED(Flags.LOCKED),
513 UNATTRIBUTED(Flags.UNATTRIBUTED),
514 ANONCONSTR(Flags.ANONCONSTR),
515 ACYCLIC(Flags.ACYCLIC),
516 PARAMETER(Flags.PARAMETER),
517 VARARGS(Flags.VARARGS),
518 ACYCLIC_ANN(Flags.ACYCLIC_ANN),
519 GENERATEDCONSTR(Flags.GENERATEDCONSTR),
520 HYPOTHETICAL(Flags.HYPOTHETICAL),
521 PROPRIETARY(Flags.PROPRIETARY),
533 AUTOMATIC_MODULE(Flags.AUTOMATIC_MODULE),
534 SYSTEM_MODULE(Flags.SYSTEM_MODULE),
535 DEPRECATED_ANNOTATION(Flags.DEPRECATED_ANNOTATION),
536 DEPRECATED_REMOVAL(Flags.DEPRECATED_REMOVAL),
537 HAS_RESOURCE(Flags.HAS_RESOURCE),
538 // Bit 48 is currently available
539 ANONCONSTR_BASED(Flags.ANONCONSTR_BASED),
540 NAME_FILLED(Flags.NAME_FILLED),
541 PREVIEW_API(Flags.PREVIEW_API),
542 PREVIEW_REFLECTIVE(Flags.PREVIEW_REFLECTIVE),
543 MATCH_BINDING(Flags.MATCH_BINDING),
544 MATCH_BINDING_TO_OUTER(Flags.MATCH_BINDING_TO_OUTER),
545 RECORD(Flags.RECORD),
546 RECOVERABLE(Flags.RECOVERABLE),
547 SEALED(Flags.SEALED),
548 NON_SEALED(Flags.NON_SEALED) {
549 @Override
550 public String toString() {
551 return "non-sealed";
552 }
553 };
554
555 Flag(long flag) {
556 this.value = flag;
557 this.lowercaseName = StringUtils.toLowerCase(name());
558 }
559
560 @Override
561 public String toString() {
562 return lowercaseName;
563 }
564
565 final long value;
566 final String lowercaseName;
567 }
568
569 }
|
88
89 /* Flag that marks a symbol synthetic, added in classfile v49.0. */
90 public static final int SYNTHETIC = 1<<12;
91
92 /** Flag that marks attribute interfaces, added in classfile v49.0. */
93 public static final int ANNOTATION = 1<<13;
94
95 /** An enumeration type or an enumeration constant, added in
96 * classfile v49.0. */
97 public static final int ENUM = 1<<14;
98
99 /** Added in SE8, represents constructs implicitly declared in source. */
100 public static final int MANDATED = 1<<15;
101
102 public static final int StandardFlags = 0x0fff;
103
104 // Because the following access flags are overloaded with other
105 // bit positions, we translate them when reading and writing class
106 // files into unique bits positions: ACC_SYNTHETIC <-> SYNTHETIC,
107 // for example.
108 public static final int ACC_IDENTITY = 0x0020;
109 public static final int ACC_BRIDGE = 0x0040;
110 public static final int ACC_VARARGS = 0x0080;
111 public static final int ACC_STRICT = 0x0800;
112 public static final int ACC_MODULE = 0x8000;
113
114 /*****************************************
115 * Internal compiler flags (no bits in the lower 16).
116 *****************************************/
117
118 /** Flag is set if symbol is deprecated. See also DEPRECATED_REMOVAL.
119 */
120 public static final int DEPRECATED = 1<<17;
121
122 /** Flag is set for a variable symbol if the variable's definition
123 * has an initializer part.
124 */
125 public static final int HASINIT = 1<<18;
126
127 /** Flag is set for a class or interface whose instances have identity
128 * i.e. any concrete class not declared with the modifier `value'
129 * (a) abstract class not declared `value'
130 * (b) older class files with ACC_SUPER bit set
131 */
132 public static final int IDENTITY_TYPE = 1<<19;
133
134 /** Class is an implicitly declared top level class.
135 */
136 public static final int IMPLICIT_CLASS = 1<<23;
137
138 /** Flag is set for compiler-generated anonymous method symbols
139 * that `own' an initializer block.
140 */
141 public static final int BLOCK = 1<<20;
142
143 /** Marks a type as a value class */
144 public static final int VALUE_CLASS = 1<<20;
145
146 /** Flag is set for ClassSymbols that are being compiled from source.
147 */
148 public static final int FROM_SOURCE = 1<<21; //ClassSymbols
149
150 /** Flag is set for nested classes that do not access instance members
151 * or `this' of an outer class and therefore don't need to be passed
152 * a this$n reference. This value is currently set only for anonymous
153 * classes in superclass constructor calls.
154 * todo: use this value for optimizing away this$n parameters in
155 * other cases.
156 */
157 public static final int NOOUTERTHIS = 1<<22;
158
159 /** Flag is set for package symbols if a package has a member or
160 * directory and therefore exists.
161 */
162 public static final int EXISTS = 1<<23;
163
164 /** Flag is set for compiler-generated compound classes
165 * representing multiple variable bounds
393 /** Flag is set for compiler-generated record members, it could be applied to
394 * accessors and fields
395 */
396 public static final int GENERATED_MEMBER = 1<<24; // MethodSymbols and VarSymbols
397
398 /**
399 * Flag to indicate sealed class/interface declaration.
400 */
401 public static final long SEALED = 1L<<62; // ClassSymbols
402
403 /**
404 * Flag to indicate restricted method declaration.
405 */
406 public static final long RESTRICTED = 1L<<62; // MethodSymbols
407
408 /**
409 * Flag to indicate that the class/interface was declared with the non-sealed modifier.
410 */
411 public static final long NON_SEALED = 1L<<63; // ClassSymbols
412
413 /**
414 * Flag to indicate that a field is strict
415 */
416 public static final long STRICT = 1L<<51; // VarSymbols
417
418 /**
419 * Describe modifier flags as they might appear in source code, i.e.,
420 * separated by spaces and in the order suggested by JLS 8.1.1.
421 */
422 public static String toSource(long flags) {
423 return asModifierSet(flags).stream()
424 .map(Modifier::toString)
425 .collect(Collectors.joining(" "));
426 }
427
428 /** Modifier masks.
429 */
430 public static final int
431 AccessFlags = PUBLIC | PROTECTED | PRIVATE,
432 LocalClassFlags = FINAL | ABSTRACT | STRICTFP | ENUM | SYNTHETIC | IDENTITY_TYPE,
433 StaticLocalClassFlags = LocalClassFlags | STATIC | INTERFACE,
434 MemberClassFlags = LocalClassFlags | INTERFACE | AccessFlags,
435 MemberStaticClassFlags = MemberClassFlags | STATIC,
436 ClassFlags = LocalClassFlags | INTERFACE | PUBLIC | ANNOTATION,
437 InterfaceVarFlags = FINAL | STATIC | PUBLIC,
438 VarFlags = AccessFlags | FINAL | STATIC |
439 VOLATILE | TRANSIENT | ENUM,
440 ConstructorFlags = AccessFlags,
441 InterfaceMethodFlags = ABSTRACT | PUBLIC,
442 MethodFlags = AccessFlags | ABSTRACT | STATIC | NATIVE |
443 SYNCHRONIZED | FINAL | STRICTFP,
444 RecordMethodFlags = AccessFlags | ABSTRACT | STATIC |
445 SYNCHRONIZED | FINAL | STRICTFP;
446 public static final long
447 ExtendedStandardFlags = (long)StandardFlags | DEFAULT | SEALED | NON_SEALED | VALUE_CLASS,
448 ExtendedMemberClassFlags = (long)MemberClassFlags | SEALED | NON_SEALED | VALUE_CLASS,
449 ExtendedMemberStaticClassFlags = (long) MemberStaticClassFlags | SEALED | NON_SEALED | VALUE_CLASS,
450 ExtendedClassFlags = (long)ClassFlags | SEALED | NON_SEALED | VALUE_CLASS,
451 ExtendedLocalClassFlags = (long) LocalClassFlags | VALUE_CLASS,
452 ExtendedStaticLocalClassFlags = (long) StaticLocalClassFlags | VALUE_CLASS,
453 ExtendedVarFlags = (long) VarFlags | STRICT,
454 ModifierFlags = ((long)StandardFlags & ~INTERFACE) | DEFAULT | SEALED | NON_SEALED | VALUE_CLASS,
455 InterfaceMethodMask = ABSTRACT | PRIVATE | STATIC | PUBLIC | STRICTFP | DEFAULT,
456 AnnotationTypeElementMask = ABSTRACT | PUBLIC,
457 LocalVarFlags = FINAL | PARAMETER,
458 ReceiverParamFlags = PARAMETER;
459
460 public static Set<Modifier> asModifierSet(long flags) {
461 Set<Modifier> modifiers = modifierSets.get(flags);
462 if (modifiers == null) {
463 modifiers = java.util.EnumSet.noneOf(Modifier.class);
464 if (0 != (flags & PUBLIC)) modifiers.add(Modifier.PUBLIC);
465 if (0 != (flags & PROTECTED)) modifiers.add(Modifier.PROTECTED);
466 if (0 != (flags & PRIVATE)) modifiers.add(Modifier.PRIVATE);
467 if (0 != (flags & ABSTRACT)) modifiers.add(Modifier.ABSTRACT);
468 if (0 != (flags & STATIC)) modifiers.add(Modifier.STATIC);
469 if (0 != (flags & SEALED)) modifiers.add(Modifier.SEALED);
470 if (0 != (flags & NON_SEALED))
471 modifiers.add(Modifier.NON_SEALED);
472 if (0 != (flags & FINAL)) modifiers.add(Modifier.FINAL);
473 if (0 != (flags & TRANSIENT)) modifiers.add(Modifier.TRANSIENT);
474 if (0 != (flags & VOLATILE)) modifiers.add(Modifier.VOLATILE);
475 if (0 != (flags & SYNCHRONIZED))
476 modifiers.add(Modifier.SYNCHRONIZED);
477 if (0 != (flags & NATIVE)) modifiers.add(Modifier.NATIVE);
478 if (0 != (flags & STRICTFP)) modifiers.add(Modifier.STRICTFP);
479 if (0 != (flags & DEFAULT)) modifiers.add(Modifier.DEFAULT);
480 if (0 != (flags & VALUE_CLASS)) modifiers.add(Modifier.VALUE);
481 modifiers = Collections.unmodifiableSet(modifiers);
482 modifierSets.put(flags, modifiers);
483 }
484 return modifiers;
485 }
486
487 // Cache of modifier sets.
488 private static final Map<Long, Set<Modifier>> modifierSets = new ConcurrentHashMap<>(64);
489
490 public static boolean isStatic(Symbol symbol) {
491 return (symbol.flags() & STATIC) != 0;
492 }
493
494 public static boolean isEnum(Symbol symbol) {
495 return (symbol.flags() & ENUM) != 0;
496 }
497
498 public static boolean isConstant(Symbol.VarSymbol symbol) {
499 return symbol.getConstValue() != null;
500 }
501
502 public enum Flag {
503 PUBLIC(Flags.PUBLIC),
504 PRIVATE(Flags.PRIVATE),
505 PROTECTED(Flags.PROTECTED),
506 STATIC(Flags.STATIC),
507 FINAL(Flags.FINAL),
508 SYNCHRONIZED(Flags.SYNCHRONIZED),
509 VOLATILE(Flags.VOLATILE),
510 TRANSIENT(Flags.TRANSIENT),
511 NATIVE(Flags.NATIVE),
512 INTERFACE(Flags.INTERFACE),
513 ABSTRACT(Flags.ABSTRACT),
514 DEFAULT(Flags.DEFAULT),
515 STRICTFP(Flags.STRICTFP),
516 BRIDGE(Flags.BRIDGE),
517 SYNTHETIC(Flags.SYNTHETIC),
518 ANNOTATION(Flags.ANNOTATION),
519 DEPRECATED(Flags.DEPRECATED),
520 HASINIT(Flags.HASINIT),
521 IDENTITY_TYPE(Flags.IDENTITY_TYPE) {
522 @Override
523 public String toString() {
524 return "identity";
525 }
526 },
527 VALUE(Flags.VALUE_CLASS),
528 IMPLICIT_CLASS(Flags.IMPLICIT_CLASS),
529 BLOCK(Flags.BLOCK),
530 FROM_SOURCE(Flags.FROM_SOURCE),
531 ENUM(Flags.ENUM),
532 MANDATED(Flags.MANDATED),
533 NOOUTERTHIS(Flags.NOOUTERTHIS),
534 EXISTS(Flags.EXISTS),
535 COMPOUND(Flags.COMPOUND),
536 CLASS_SEEN(Flags.CLASS_SEEN),
537 SOURCE_SEEN(Flags.SOURCE_SEEN),
538 LOCKED(Flags.LOCKED),
539 UNATTRIBUTED(Flags.UNATTRIBUTED),
540 ANONCONSTR(Flags.ANONCONSTR),
541 ACYCLIC(Flags.ACYCLIC),
542 PARAMETER(Flags.PARAMETER),
543 VARARGS(Flags.VARARGS),
544 ACYCLIC_ANN(Flags.ACYCLIC_ANN),
545 GENERATEDCONSTR(Flags.GENERATEDCONSTR),
546 HYPOTHETICAL(Flags.HYPOTHETICAL),
547 PROPRIETARY(Flags.PROPRIETARY),
559 AUTOMATIC_MODULE(Flags.AUTOMATIC_MODULE),
560 SYSTEM_MODULE(Flags.SYSTEM_MODULE),
561 DEPRECATED_ANNOTATION(Flags.DEPRECATED_ANNOTATION),
562 DEPRECATED_REMOVAL(Flags.DEPRECATED_REMOVAL),
563 HAS_RESOURCE(Flags.HAS_RESOURCE),
564 // Bit 48 is currently available
565 ANONCONSTR_BASED(Flags.ANONCONSTR_BASED),
566 NAME_FILLED(Flags.NAME_FILLED),
567 PREVIEW_API(Flags.PREVIEW_API),
568 PREVIEW_REFLECTIVE(Flags.PREVIEW_REFLECTIVE),
569 MATCH_BINDING(Flags.MATCH_BINDING),
570 MATCH_BINDING_TO_OUTER(Flags.MATCH_BINDING_TO_OUTER),
571 RECORD(Flags.RECORD),
572 RECOVERABLE(Flags.RECOVERABLE),
573 SEALED(Flags.SEALED),
574 NON_SEALED(Flags.NON_SEALED) {
575 @Override
576 public String toString() {
577 return "non-sealed";
578 }
579 },
580 STRICT(Flags.STRICT);
581
582 Flag(long flag) {
583 this.value = flag;
584 this.lowercaseName = StringUtils.toLowerCase(name());
585 }
586
587 @Override
588 public String toString() {
589 return lowercaseName;
590 }
591
592 final long value;
593 final String lowercaseName;
594 }
595
596 }
|