1 // $Id: access.h,v 1.24 2004/02/23 13:47:11 ericb Exp $ -*- c++ -*- 2 // 3 // This software is subject to the terms of the IBM Jikes Compiler 4 // License Agreement available at the following URL: 5 // http://ibm.com/developerworks/opensource/jikes. 6 // Copyright (C) 1996, 2004 IBM Corporation and others. All Rights Reserved. 7 // You must accept the terms of that agreement to use this software. 8 // 9 10 #ifndef access_INCLUDED 11 #define access_INCLUDED 12 13 #include "platform.h" 14 15 #ifdef HAVE_JIKES_NAMESPACE 16 namespace Jikes { // Open namespace Jikes block 17 #endif 18 19 20 class AccessFlags 21 { 22 public: 23 enum 24 { 25 ACCESS_PUBLIC = 0x0001, 26 ACCESS_PRIVATE = 0x0002, 27 ACCESS_PROTECTED = 0x0004, 28 ACCESS_STATIC = 0x0008, 29 ACCESS_FINAL = 0x0010, 30 ACCESS_SYNCHRONIZED = 0x0020, 31 ACCESS_SUPER = 0x0020, 32 ACCESS_VOLATILE = 0x0040, 33 ACCESS_BRIDGE = 0x0040, // JSR 14 34 ACCESS_TRANSIENT = 0x0080, 35 ACCESS_VARARGS = 0x0080, // JSR 201 36 ACCESS_NATIVE = 0x0100, 37 ACCESS_ENUM = 0x0100, // JSR 201 38 ACCESS_INTERFACE = 0x0200, 39 ACCESS_ABSTRACT = 0x0400, 40 ACCESS_STRICTFP = 0x0800, 41 ACCESS_SYNTHETIC = 0x1000, // JSR 201 42 ACCESS_ANNOTATION = 0x2000, // JSR 175 43 ACCESS_ACCESS = ACCESS_PUBLIC | ACCESS_PROTECTED | ACCESS_PRIVATE 44 }; 45 46 protected: 47 u2 access_flags; 48 49 public: access_flags(flags)50 AccessFlags(u2 flags = 0) : access_flags(flags) {} 51 IsSet(u2 flag)52 bool IsSet(u2 flag) const { return (access_flags & flag) != 0; } ACC_PUBLIC()53 bool ACC_PUBLIC() const { return IsSet(ACCESS_PUBLIC); } ACC_PRIVATE()54 bool ACC_PRIVATE() const { return IsSet(ACCESS_PRIVATE); } ACC_PROTECTED()55 bool ACC_PROTECTED() const { return IsSet(ACCESS_PROTECTED); } ACC_STATIC()56 bool ACC_STATIC() const { return IsSet(ACCESS_STATIC); } ACC_FINAL()57 bool ACC_FINAL() const { return IsSet(ACCESS_FINAL); } ACC_SYNCHRONIZED()58 bool ACC_SYNCHRONIZED() const { return IsSet(ACCESS_SYNCHRONIZED); } ACC_SUPER()59 bool ACC_SUPER() const { return IsSet(ACCESS_SUPER); } ACC_VOLATILE()60 bool ACC_VOLATILE() const { return IsSet(ACCESS_VOLATILE); } ACC_BRIDGE()61 bool ACC_BRIDGE() const { return IsSet(ACCESS_BRIDGE); } ACC_TRANSIENT()62 bool ACC_TRANSIENT() const { return IsSet(ACCESS_TRANSIENT); } ACC_VARARGS()63 bool ACC_VARARGS() const { return IsSet(ACCESS_VARARGS); } ACC_NATIVE()64 bool ACC_NATIVE() const { return IsSet(ACCESS_NATIVE); } ACC_ENUM()65 bool ACC_ENUM() const { return IsSet(ACCESS_ENUM); } ACC_INTERFACE()66 bool ACC_INTERFACE() const { return IsSet(ACCESS_INTERFACE); } ACC_ABSTRACT()67 bool ACC_ABSTRACT() const { return IsSet(ACCESS_ABSTRACT); } ACC_STRICTFP()68 bool ACC_STRICTFP() const { return IsSet(ACCESS_STRICTFP); } ACC_SYNTHETIC()69 bool ACC_SYNTHETIC() const { return IsSet(ACCESS_SYNTHETIC); } ACC_ANNOTATION()70 bool ACC_ANNOTATION() const { return IsSet(ACCESS_ANNOTATION); } 71 SetFlags(u2 flag)72 void SetFlags(u2 flag) { access_flags |= flag; } SetFlags(const AccessFlags & af)73 void SetFlags(const AccessFlags& af) { access_flags = af.access_flags; } SetACC_PUBLIC()74 void SetACC_PUBLIC() { SetFlags(ACCESS_PUBLIC); } SetACC_PRIVATE()75 void SetACC_PRIVATE() { SetFlags(ACCESS_PRIVATE); } SetACC_PROTECTED()76 void SetACC_PROTECTED() { SetFlags(ACCESS_PROTECTED); } SetACC_STATIC()77 void SetACC_STATIC() { SetFlags(ACCESS_STATIC); } SetACC_FINAL()78 void SetACC_FINAL() { SetFlags(ACCESS_FINAL); } SetACC_SYNCHRONIZED()79 void SetACC_SYNCHRONIZED() { SetFlags(ACCESS_SYNCHRONIZED); } SetACC_SUPER()80 void SetACC_SUPER() { SetFlags(ACCESS_SUPER); } SetACC_VOLATILE()81 void SetACC_VOLATILE() { SetFlags(ACCESS_VOLATILE); } SetACC_BRIDGE()82 void SetACC_BRIDGE() { SetFlags(ACCESS_BRIDGE); } SetACC_TRANSIENT()83 void SetACC_TRANSIENT() { SetFlags(ACCESS_TRANSIENT); } SetACC_VARARGS()84 void SetACC_VARARGS() { SetFlags(ACCESS_VARARGS); } SetACC_NATIVE()85 void SetACC_NATIVE() { SetFlags(ACCESS_NATIVE); } SetACC_ENUM()86 void SetACC_ENUM() { SetFlags(ACCESS_ENUM); } SetACC_INTERFACE()87 void SetACC_INTERFACE() { SetFlags(ACCESS_INTERFACE); } SetACC_ABSTRACT()88 void SetACC_ABSTRACT() { SetFlags(ACCESS_ABSTRACT); } SetACC_STRICTFP()89 void SetACC_STRICTFP() { SetFlags(ACCESS_STRICTFP); } SetACC_SYNTHETIC()90 void SetACC_SYNTHETIC() { SetFlags(ACCESS_SYNTHETIC); } SetACC_ANNOTATION()91 void SetACC_ANNOTATION() { SetFlags(ACCESS_ANNOTATION); } 92 93 void ResetFlags(u2 flag = 0xffff) { access_flags &= ~ flag; } ResetACC_PUBLIC()94 void ResetACC_PUBLIC() { ResetFlags(ACCESS_PUBLIC); } ResetACC_PRIVATE()95 void ResetACC_PRIVATE() { ResetFlags(ACCESS_PRIVATE); } ResetACC_PROTECTED()96 void ResetACC_PROTECTED() { ResetFlags(ACCESS_PROTECTED); } ResetACC_STATIC()97 void ResetACC_STATIC() { ResetFlags(ACCESS_STATIC); } ResetACC_FINAL()98 void ResetACC_FINAL() { ResetFlags(ACCESS_FINAL); } ResetACC_SYNCHRONIZED()99 void ResetACC_SYNCHRONIZED() { ResetFlags(ACCESS_SYNCHRONIZED); } ResetACC_SUPER()100 void ResetACC_SUPER() { ResetFlags(ACCESS_SUPER); } ResetACC_VOLATILE()101 void ResetACC_VOLATILE() { ResetFlags(ACCESS_VOLATILE); } ResetACC_BRIDGE()102 void ResetACC_BRIDGE() { ResetFlags(ACCESS_BRIDGE); } ResetACC_TRANSIENT()103 void ResetACC_TRANSIENT() { ResetFlags(ACCESS_TRANSIENT); } ResetACC_VARARGS()104 void ResetACC_VARARGS() { ResetFlags(ACCESS_VARARGS); } ResetACC_NATIVE()105 void ResetACC_NATIVE() { ResetFlags(ACCESS_NATIVE); } ResetACC_ENUM()106 void ResetACC_ENUM() { ResetFlags(ACCESS_ENUM); } ResetACC_INTERFACE()107 void ResetACC_INTERFACE() { ResetFlags(ACCESS_INTERFACE); } ResetACC_ABSTRACT()108 void ResetACC_ABSTRACT() { ResetFlags(ACCESS_ABSTRACT); } ResetACC_STRICTFP()109 void ResetACC_STRICTFP() { ResetFlags(ACCESS_STRICTFP); } ResetACC_SYNTHETIC()110 void ResetACC_SYNTHETIC() { ResetFlags(ACCESS_SYNTHETIC); } ResetACC_ANNOTATION()111 void ResetACC_ANNOTATION() { ResetFlags(ACCESS_ANNOTATION); } 112 Flags()113 u2 Flags() const { return access_flags; } 114 AccessString()115 inline const wchar_t* AccessString() const 116 { 117 return (ACC_PUBLIC() ? StringConstant::US_public 118 : ACC_PROTECTED() ? StringConstant::US_protected 119 : ACC_PRIVATE() ? StringConstant::US_private 120 : StringConstant::US_default); 121 } 122 LegalAccess()123 inline bool LegalAccess() 124 { 125 u2 acc = access_flags & ACCESS_ACCESS; 126 return (acc & - acc) == acc; 127 } 128 129 // 130 // Return true if adding flag will not violate recommended ordering of 131 // modifiers based on the modifiers already set. 132 // RecommendedOrder(const u2 flag)133 bool RecommendedOrder(const u2 flag) 134 { 135 u2 later_flags = 0; 136 switch (flag) 137 { 138 case ACCESS_PUBLIC: 139 case ACCESS_PRIVATE: 140 case ACCESS_PROTECTED: 141 later_flags = ACCESS_ABSTRACT | ACCESS_STATIC | ACCESS_FINAL | 142 ACCESS_SYNCHRONIZED | ACCESS_TRANSIENT | ACCESS_VOLATILE | 143 ACCESS_NATIVE | ACCESS_STRICTFP; 144 break; 145 case ACCESS_ABSTRACT: 146 later_flags = ACCESS_STATIC | ACCESS_FINAL | ACCESS_SYNCHRONIZED | 147 ACCESS_TRANSIENT | ACCESS_VOLATILE | ACCESS_NATIVE | 148 ACCESS_STRICTFP; 149 break; 150 case ACCESS_STATIC: 151 later_flags = ACCESS_FINAL | ACCESS_SYNCHRONIZED | 152 ACCESS_TRANSIENT | ACCESS_VOLATILE | ACCESS_NATIVE | 153 ACCESS_STRICTFP; 154 break; 155 case ACCESS_FINAL: 156 later_flags = ACCESS_SYNCHRONIZED | ACCESS_TRANSIENT | 157 ACCESS_VOLATILE | ACCESS_NATIVE | ACCESS_STRICTFP; 158 break; 159 case ACCESS_SYNCHRONIZED: 160 later_flags = ACCESS_TRANSIENT | ACCESS_VOLATILE | ACCESS_NATIVE | 161 ACCESS_STRICTFP; 162 break; 163 case ACCESS_TRANSIENT: 164 later_flags = ACCESS_VOLATILE | ACCESS_NATIVE | ACCESS_STRICTFP; 165 break; 166 case ACCESS_VOLATILE: 167 later_flags = ACCESS_NATIVE | ACCESS_STRICTFP; 168 break; 169 case ACCESS_NATIVE: 170 later_flags = ACCESS_STRICTFP; 171 break; 172 case ACCESS_STRICTFP: 173 break; 174 default: 175 assert(false && "invalid modifier"); 176 } 177 return ! IsSet(later_flags); 178 } 179 180 #ifdef JIKES_DEBUG 181 enum AccessMetatype 182 { 183 ACCESS_TYPE, 184 ACCESS_VARIABLE, 185 ACCESS_METHOD 186 }; 187 Print(AccessMetatype metatype)188 void Print(AccessMetatype metatype) const 189 { 190 Coutput << "access_flags: 0x" << IntToString(access_flags, 4).String(); 191 if (ACC_PUBLIC()) 192 Coutput << " public"; 193 if (ACC_PRIVATE()) 194 Coutput << " private"; 195 if (ACC_PROTECTED()) 196 Coutput << " protected"; 197 if (ACC_STATIC()) 198 Coutput << " static"; 199 if (ACC_FINAL()) 200 Coutput << " final"; 201 // The next bits are shared; the metatype determines the meaning. 202 if (ACC_SYNCHRONIZED()) 203 Coutput << (metatype == ACCESS_TYPE ? " super" : " synchronized"); 204 if (ACC_VOLATILE()) 205 Coutput << (metatype == ACCESS_METHOD ? " bridge" : " volatile"); 206 if (ACC_TRANSIENT()) 207 Coutput << (metatype == ACCESS_METHOD ? " varags" : " transient"); 208 if (ACC_NATIVE()) 209 Coutput << (metatype == ACCESS_VARIABLE ? " enum" : " native"); 210 if (ACC_INTERFACE()) 211 Coutput << " interface"; 212 if (ACC_ABSTRACT()) 213 Coutput << " abstract"; 214 if (ACC_STRICTFP()) 215 Coutput << " strictfp"; 216 if (ACC_SYNTHETIC()) 217 Coutput << " synthetic"; 218 if (ACC_ANNOTATION()) 219 Coutput << " annotation"; 220 Coutput << endl; 221 } 222 #endif // JIKES_DEBUG 223 }; 224 225 #ifdef HAVE_JIKES_NAMESPACE 226 } // Close namespace Jikes block 227 #endif 228 229 #endif // access_INCLUDED 230 231