Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/classfile/AccessFlags.java

src/share/classes/com/sun/tools/classfile/AccessFlags.java

changeset 300
ed989c347b3c
parent 54
eaf608c64fec
child 345
23505e6ea22d
equal deleted inserted replaced
299:22872b24d38c 300:ed989c347b3c
56 public static final int ACC_SYNTHETIC = 0x1000; // class, inner, field, method 56 public static final int ACC_SYNTHETIC = 0x1000; // class, inner, field, method
57 public static final int ACC_ANNOTATION = 0x2000; // class, inner 57 public static final int ACC_ANNOTATION = 0x2000; // class, inner
58 public static final int ACC_ENUM = 0x4000; // class, inner, field 58 public static final int ACC_ENUM = 0x4000; // class, inner, field
59 public static final int ACC_MODULE = 0x8000; // class, inner, field, method 59 public static final int ACC_MODULE = 0x8000; // class, inner, field, method
60 60
61 private static enum Type { Class, InnerClass, Field, Method}; 61 public static enum Kind { Class, InnerClass, Field, Method};
62 62
63 AccessFlags(ClassReader cr) throws IOException { 63 AccessFlags(ClassReader cr) throws IOException {
64 this(cr.readUnsignedShort()); 64 this(cr.readUnsignedShort());
65 } 65 }
66 66
85 ACC_SYNTHETIC, ACC_ANNOTATION, ACC_ENUM, ACC_MODULE 85 ACC_SYNTHETIC, ACC_ANNOTATION, ACC_ENUM, ACC_MODULE
86 }; 86 };
87 87
88 public Set<String> getClassModifiers() { 88 public Set<String> getClassModifiers() {
89 int f = ((flags & ACC_INTERFACE) != 0 ? flags & ~ACC_ABSTRACT : flags); 89 int f = ((flags & ACC_INTERFACE) != 0 ? flags & ~ACC_ABSTRACT : flags);
90 return getModifiers(f, classModifiers, Type.Class); 90 return getModifiers(f, classModifiers, Kind.Class);
91 } 91 }
92 92
93 public Set<String> getClassFlags() { 93 public Set<String> getClassFlags() {
94 return getFlags(classFlags, Type.Class); 94 return getFlags(classFlags, Kind.Class);
95 } 95 }
96 96
97 private static final int[] innerClassModifiers = { 97 private static final int[] innerClassModifiers = {
98 ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL, 98 ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL,
99 ACC_ABSTRACT, ACC_MODULE 99 ACC_ABSTRACT, ACC_MODULE
104 ACC_INTERFACE, ACC_ABSTRACT, ACC_SYNTHETIC, ACC_ANNOTATION, ACC_ENUM, ACC_MODULE 104 ACC_INTERFACE, ACC_ABSTRACT, ACC_SYNTHETIC, ACC_ANNOTATION, ACC_ENUM, ACC_MODULE
105 }; 105 };
106 106
107 public Set<String> getInnerClassModifiers() { 107 public Set<String> getInnerClassModifiers() {
108 int f = ((flags & ACC_INTERFACE) != 0 ? flags & ~ACC_ABSTRACT : flags); 108 int f = ((flags & ACC_INTERFACE) != 0 ? flags & ~ACC_ABSTRACT : flags);
109 return getModifiers(f, innerClassModifiers, Type.InnerClass); 109 return getModifiers(f, innerClassModifiers, Kind.InnerClass);
110 } 110 }
111 111
112 public Set<String> getInnerClassFlags() { 112 public Set<String> getInnerClassFlags() {
113 return getFlags(innerClassFlags, Type.InnerClass); 113 return getFlags(innerClassFlags, Kind.InnerClass);
114 } 114 }
115 115
116 private static final int[] fieldModifiers = { 116 private static final int[] fieldModifiers = {
117 ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL, 117 ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL,
118 ACC_VOLATILE, ACC_TRANSIENT, ACC_MODULE 118 ACC_VOLATILE, ACC_TRANSIENT, ACC_MODULE
122 ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL, 122 ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL,
123 ACC_VOLATILE, ACC_TRANSIENT, ACC_SYNTHETIC, ACC_ENUM, ACC_MODULE 123 ACC_VOLATILE, ACC_TRANSIENT, ACC_SYNTHETIC, ACC_ENUM, ACC_MODULE
124 }; 124 };
125 125
126 public Set<String> getFieldModifiers() { 126 public Set<String> getFieldModifiers() {
127 return getModifiers(fieldModifiers, Type.Field); 127 return getModifiers(fieldModifiers, Kind.Field);
128 } 128 }
129 129
130 public Set<String> getFieldFlags() { 130 public Set<String> getFieldFlags() {
131 return getFlags(fieldFlags, Type.Field); 131 return getFlags(fieldFlags, Kind.Field);
132 } 132 }
133 133
134 private static final int[] methodModifiers = { 134 private static final int[] methodModifiers = {
135 ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL, 135 ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL,
136 ACC_SYNCHRONIZED, ACC_NATIVE, ACC_ABSTRACT, ACC_STRICT, ACC_MODULE 136 ACC_SYNCHRONIZED, ACC_NATIVE, ACC_ABSTRACT, ACC_STRICT, ACC_MODULE
141 ACC_SYNCHRONIZED, ACC_BRIDGE, ACC_VARARGS, ACC_NATIVE, ACC_ABSTRACT, 141 ACC_SYNCHRONIZED, ACC_BRIDGE, ACC_VARARGS, ACC_NATIVE, ACC_ABSTRACT,
142 ACC_STRICT, ACC_SYNTHETIC, ACC_MODULE 142 ACC_STRICT, ACC_SYNTHETIC, ACC_MODULE
143 }; 143 };
144 144
145 public Set<String> getMethodModifiers() { 145 public Set<String> getMethodModifiers() {
146 return getModifiers(methodModifiers, Type.Method); 146 return getModifiers(methodModifiers, Kind.Method);
147 } 147 }
148 148
149 public Set<String> getMethodFlags() { 149 public Set<String> getMethodFlags() {
150 return getFlags(methodFlags, Type.Method); 150 return getFlags(methodFlags, Kind.Method);
151 } 151 }
152 152
153 private Set<String> getModifiers(int[] modifierFlags, Type t) { 153 private Set<String> getModifiers(int[] modifierFlags, Kind t) {
154 return getModifiers(flags, modifierFlags, t); 154 return getModifiers(flags, modifierFlags, t);
155 } 155 }
156 156
157 private static Set<String> getModifiers(int flags, int[] modifierFlags, Type t) { 157 private static Set<String> getModifiers(int flags, int[] modifierFlags, Kind t) {
158 Set<String> s = new LinkedHashSet<String>(); 158 Set<String> s = new LinkedHashSet<String>();
159 for (int m: modifierFlags) { 159 for (int m: modifierFlags) {
160 if ((flags & m) != 0) 160 if ((flags & m) != 0)
161 s.add(flagToModifier(m, t)); 161 s.add(flagToModifier(m, t));
162 } 162 }
163 return s; 163 return s;
164 } 164 }
165 165
166 private Set<String> getFlags(int[] expectedFlags, Type t) { 166 private Set<String> getFlags(int[] expectedFlags, Kind t) {
167 Set<String> s = new LinkedHashSet<String>(); 167 Set<String> s = new LinkedHashSet<String>();
168 int f = flags; 168 int f = flags;
169 for (int e: expectedFlags) { 169 for (int e: expectedFlags) {
170 if ((f & e) != 0) { 170 if ((f & e) != 0) {
171 s.add(flagToName(e, t)); 171 s.add(flagToName(e, t));
178 f = f & ~bit; 178 f = f & ~bit;
179 } 179 }
180 return s; 180 return s;
181 } 181 }
182 182
183 private static String flagToModifier(int flag, Type t) { 183 private static String flagToModifier(int flag, Kind t) {
184 switch (flag) { 184 switch (flag) {
185 case ACC_PUBLIC: 185 case ACC_PUBLIC:
186 return "public"; 186 return "public";
187 case ACC_PRIVATE: 187 case ACC_PRIVATE:
188 return "private"; 188 return "private";
193 case ACC_FINAL: 193 case ACC_FINAL:
194 return "final"; 194 return "final";
195 case ACC_SYNCHRONIZED: 195 case ACC_SYNCHRONIZED:
196 return "synchronized"; 196 return "synchronized";
197 case 0x80: 197 case 0x80:
198 return (t == Type.Field ? "transient" : null); 198 return (t == Kind.Field ? "transient" : null);
199 case ACC_VOLATILE: 199 case ACC_VOLATILE:
200 return "volatile"; 200 return "volatile";
201 case ACC_NATIVE: 201 case ACC_NATIVE:
202 return "native"; 202 return "native";
203 case ACC_ABSTRACT: 203 case ACC_ABSTRACT:
209 default: 209 default:
210 return null; 210 return null;
211 } 211 }
212 } 212 }
213 213
214 private static String flagToName(int flag, Type t) { 214 private static String flagToName(int flag, Kind t) {
215 switch (flag) { 215 switch (flag) {
216 case ACC_PUBLIC: 216 case ACC_PUBLIC:
217 return "ACC_PUBLIC"; 217 return "ACC_PUBLIC";
218 case ACC_PRIVATE: 218 case ACC_PRIVATE:
219 return "ACC_PRIVATE"; 219 return "ACC_PRIVATE";
222 case ACC_STATIC: 222 case ACC_STATIC:
223 return "ACC_STATIC"; 223 return "ACC_STATIC";
224 case ACC_FINAL: 224 case ACC_FINAL:
225 return "ACC_FINAL"; 225 return "ACC_FINAL";
226 case 0x20: 226 case 0x20:
227 return (t == Type.Class ? "ACC_SUPER" : "ACC_SYNCHRONIZED"); 227 return (t == Kind.Class ? "ACC_SUPER" : "ACC_SYNCHRONIZED");
228 case 0x40: 228 case 0x40:
229 return (t == Type.Field ? "ACC_VOLATILE" : "ACC_BRIDGE"); 229 return (t == Kind.Field ? "ACC_VOLATILE" : "ACC_BRIDGE");
230 case 0x80: 230 case 0x80:
231 return (t == Type.Field ? "ACC_TRANSIENT" : "ACC_VARARGS"); 231 return (t == Kind.Field ? "ACC_TRANSIENT" : "ACC_VARARGS");
232 case ACC_NATIVE: 232 case ACC_NATIVE:
233 return "ACC_NATIVE"; 233 return "ACC_NATIVE";
234 case ACC_INTERFACE: 234 case ACC_INTERFACE:
235 return "ACC_INTERFACE"; 235 return "ACC_INTERFACE";
236 case ACC_ABSTRACT: 236 case ACC_ABSTRACT:
248 default: 248 default:
249 return null; 249 return null;
250 } 250 }
251 } 251 }
252 252
253 final int flags; 253 public final int flags;
254 } 254 }

Mercurial Repository: jdk8-mips64-public/langtools

mercurial